# Google Maps Reviewer Geo Profile API (`johnvc/google-maps-reviewer-geo-profile-api`) Actor

Infer a Google Maps reviewer's home region from their review history. Clusters review coordinates into a standardized home-region guess (city/state/country + ISO codes), a confidence score, and a local-vs-travel footprint. One row per reviewer, for reviewer vetting and fraud research. MCP-ready.

- **URL**: https://apify.com/johnvc/google-maps-reviewer-geo-profile-api.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:** Lead generation, Developer tools, MCP servers
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 contributor analyzeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Maps Reviewer Geo Profile API

Infer a Google Maps reviewer's home region from their public review history. Give the API a contributor ID and it fetches that reviewer's reviews, reverse-geocodes the coordinates attached to every review, and clusters them into a single derived profile: a standardized home-region guess (city, state, country, plus ISO codes), a confidence score, how many reviews sit in the home cluster versus travel outliers, a compact footprint of the regions they review in, and a centroid and bounding box. One row per reviewer.

Built for aggregate reviewer vetting, reputation research, and review-fraud detection. It answers "where is this reviewer based, and how far do they roam?" at region level. It is not a tool for locating a specific individual, and it deliberately stops at city/region granularity.

### What you get

One derived row per reviewer:

- Home region: `home_region_guess` plus the standardized breakdown `home_city`, `home_admin` (state/province), `home_admin_code` (ISO 3166-2), `home_country`, `home_country_code` (ISO 3166-1)
- Signal quality: `confidence`, `home_cluster_size`, `travel_outliers`, `located_reviews`, `total_reviews`, `distinct_regions`
- Footprint: `footprint`, the top regions the reviewer reviews in, each with a count and a share
- Geometry: `centroid` (mean lat/lon of the home cluster) and `bounding_box` (the full geographic spread)
- Reviewer profile for context: `contributor_name`, `contributor_level`, `contributor_local_guide`, `contributor_points`, `contributor_contributions`

### How it works

Every Google Maps review carries the coordinates of the place reviewed. This API reverse-geocodes those coordinates offline against a bundled GeoNames dataset, so the region output is standardized and language-independent (it does not depend on how the address happens to be written). The densest cluster of a reviewer's reviews is a strong proxy for where they are based; the scattered tail is travel. Deeper history sharpens the signal, so raise `maxResultsPerContributor` when a reviewer's recent activity skews toward travel.

### Use cases

- Vet a reviewer before trusting their reviews: does their footprint look like a real local, or a scattered pattern typical of paid reviews?
- Reputation research: profile an expert witness, public figure, or vendor by the region their review history clusters in
- Review-fraud detection: flag accounts whose reviews are spread implausibly wide or concentrated on a single distant target
- Compare a batch of reviewers on one place to see whether they share an improbable geographic pattern
- Feed an AI agent a reviewer's geo profile to summarize whether their reviews are locally coherent

### Input

| Field | Type | Description |
|-------|------|-------------|
| `contributorId` | string | A single Google Maps contributor ID (the long numeric ID from a reviewer's profile). Provide this, `contributorIds`, or both. |
| `contributorIds` | array of strings | A batch of contributor IDs to profile in one run. Merged with `contributorId` and de-duplicated. |
| `regionGranularity` | string | Level the home-region guess is computed at: `city` (default), `admin1` (state/province), or `country`. |
| `hl` | string | Optional two-letter language code for the source reviews. Default `en`. |
| `maxResultsPerContributor` | integer | Reviews to analyze per contributor, most recent first. Default 100, maximum 200. |

You can read a contributor ID from any place review's reviewer.

#### Choosing a granularity

- `city` gives the sharpest answer (e.g. "Chicago, IL") and is the default.
- `admin1` rolls up to state/province, which is steadier for reviewers who move around a metro area.
- `country` is best for spotting cross-border patterns.

The row always includes the full standardized breakdown (city, admin, country, ISO codes) no matter which granularity drives the headline `home_region_guess`.

#### Example input

```json
{
  "contributorId": "107022004965696773221",
  "regionGranularity": "city",
  "maxResultsPerContributor": 100
}
````

### Sample output

```json
{
  "result_type": "reviewer_geo_profile",
  "contributor_id": "107022004965696773221",
  "contributor_name": "Matt Moeini",
  "contributor_level": 5,
  "contributor_local_guide": true,
  "home_region_guess": "Chicago, IL",
  "home_city": "Chicago",
  "home_admin": "Illinois",
  "home_admin_code": "US-IL",
  "home_country": "United States",
  "home_country_code": "US",
  "confidence": 0.72,
  "home_cluster_size": 23,
  "travel_outliers": 9,
  "located_reviews": 32,
  "total_reviews": 32,
  "distinct_regions": 6,
  "region_granularity": "city",
  "footprint": [
    { "region": "Chicago, IL", "count": 23, "share": 0.7188 },
    { "region": "Miami, FL", "count": 3, "share": 0.0938 }
  ],
  "centroid": { "latitude": 41.9354, "longitude": -87.6443 },
  "bounding_box": { "min_latitude": 25.7617, "min_longitude": -87.6847, "max_latitude": 41.9784, "max_longitude": -80.1918 }
}
```

### Pricing

Pay-per-event: a small `actor_start` fee plus one charge per contributor analyzed. You pay once per reviewer, regardless of how deep the history goes, so pulling a full 200-review history to sharpen the signal costs the same as a shallow run.

| Plan | Per contributor analyzed | Start fee |
|---|---|---|
| Free | $0.02 | $0.001 |
| Bronze | $0.015 | $0.001 |

### How to get started

1. Open [Google Maps Reviewer Geo Profile on the Apify Store](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api?fpr=9n7kx3).
2. Enter a `contributorId` (or a `contributorIds` list).
3. Run the Actor and read the derived home-region profile from the dataset.
4. Export as JSON, CSV, or Excel, or pull it from the API.

Prefer code? See [johnvc's GitHub for setup guides and code examples](https://github.com/johnisanerd/ApifyPublicData).

### Run from the API

```bash
curl -X POST "https://api.apify.com/v2/acts/johnvc~google-maps-reviewer-geo-profile-api/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"contributorId":"107022004965696773221","regionGranularity":"city"}'
```

### 🔌 Use this API from Claude (MCP)

This Actor is compatible with the Model Context Protocol (MCP), so AI agents can call it as a tool. Add it through the hosted Apify MCP server using this Actor-specific URL:

https://mcp.apify.com/?tools=actors,docs,johnvc/google-maps-reviewer-geo-profile-api

If you run agents from [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial) or [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), add the Apify MCP server and ask it to "profile this reviewer's home region and tell me whether their footprint looks locally coherent."

Apify MCP integration docs: https://docs.apify.com/platform/integrations/mcp

### Data and attribution

Region names, ISO codes, and coordinates are resolved offline using data from [GeoNames](https://www.geonames.org/), licensed under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).

### FAQ

**What is a contributor ID?** It is the long numeric ID that identifies a Google Maps reviewer. You can read it from any place review's reviewer profile, then pass it here.

**Can this locate a specific individual?** No. It reports an aggregate, region-level home area derived from where a reviewer's public reviews cluster. It does not resolve a home address or track a person, and it stops at city/region granularity by design. Use it for reviewer vetting and reputation or fraud research, not to identify where someone lives.

**How accurate is the home region?** It reflects where the reviewer's reviews cluster, which is a strong proxy for a home base but not a guarantee. The `confidence` score tells you how concentrated the cluster is, and `located_reviews` tells you how much data it is based on. Deeper history (raise `maxResultsPerContributor`) improves it.

**What if a reviewer travels a lot?** The `travel_outliers` count and the `footprint` show the spread. A low `confidence` with many distinct regions is exactly the signal that a reviewer roams (or that the account is not a genuine local).

**Can I profile many reviewers at once?** Yes. Pass a `contributorIds` list; each reviewer is analyzed independently and returned as its own row.

**Why standardized ISO codes?** So you can group or filter reviewers by country (`home_country_code`) or state/province (`home_admin_code`) without parsing free-text addresses that vary by language.

### Featured Tasks

Ready-to-run examples that show this API solving a specific problem. Each opens its own setup so you can run it on your account in one click.

- [Detect Out-of-Town Google Reviewers](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/detect-out-of-town-google-reviewers?fpr=9n7kx3)
- [Profile a Google Reviewer's Location via MCP](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/profile-a-google-reviewer-s-location-via-mcp?fpr=9n7kx3)
- [Verify a Google Reviewer Is a Real Local](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/verify-a-google-reviewer-is-a-real-local?fpr=9n7kx3)
- [Find a Google Reviewer's Home Country](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/find-a-google-reviewer-s-home-country?fpr=9n7kx3)
- [Spot Geographically Inconsistent Reviewers](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/spot-geographically-inconsistent-reviewers?fpr=9n7kx3)
- [Bulk-Analyze Google Reviewers' Home Regions](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/bulk-analyze-google-reviewers-home-regions?fpr=9n7kx3)

#### Также на русском (Russian)

- [Проверка иногородних авторов отзывов Google Maps: API](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/detect-out-of-town-google-reviewers-ru?fpr=9n7kx3)
- [Гео-профиль автора отзывов Google Maps через MCP](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/profile-a-google-reviewer-s-location-via-mcp-ru?fpr=9n7kx3)
- [Проверка автора отзывов Google: местный или нет](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/verify-a-google-reviewer-is-a-real-local-ru?fpr=9n7kx3)
- [Страна и город автора отзывов Google Maps по API](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/find-a-google-reviewer-s-home-country-ru?fpr=9n7kx3)
- [Выявление фейковых отзывов: география авторов на картах](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/spot-geographically-inconsistent-reviewers-ru?fpr=9n7kx3)
- [API: массовый анализ регионов авторов отзывов Google Карт](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/bulk-analyze-google-reviewers-home-regions-ru?fpr=9n7kx3)

#### 中文版 (Chinese)

- [识别异地Google Maps评论者：常驻地区+置信度反刷评](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/detect-out-of-town-google-reviewers-zh?fpr=9n7kx3)
- [让AI通过MCP推断谷歌地图评论者的家乡地区与出行足迹](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/profile-a-google-reviewer-s-location-via-mcp-zh?fpr=9n7kx3)
- [谷歌地图评论者本地身份核验：置信度评分与足迹分析](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/verify-a-google-reviewer-is-a-real-local-zh?fpr=9n7kx3)
- [谷歌地图评论者所在国家与城市识别｜ISO代码地区归属推断API](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/find-a-google-reviewer-s-home-country-zh?fpr=9n7kx3)
- [谷歌地图虚假评论检测API：识别地理位置异常的评论者](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/spot-geographically-inconsistent-reviewers-zh?fpr=9n7kx3)
- [批量分析谷歌地图评论者常住地区与出行足迹｜信誉与虚假评论调查API](https://apify.com/johnvc/google-maps-reviewer-geo-profile-api/examples/bulk-analyze-google-reviewers-home-regions-zh?fpr=9n7kx3)

### n8n integration

Available as an n8n community node, **[n8n-nodes-google-maps-reviewer-geo-profile-api](https://www.npmjs.com/package/n8n-nodes-google-maps-reviewer-geo-profile-api)**. In n8n: Settings, Community Nodes, install `n8n-nodes-google-maps-reviewer-geo-profile-api`, then use it in any workflow (it also works as an AI Agent tool).

Last Updated: 2026.07.08

# Actor input Schema

## `contributorId` (type: `string`):

Enter a single Google Maps contributor ID (the long numeric ID from a reviewer's profile, e.g. '107022004965696773221'). Provide this, `contributorIds`, or both. You can read a contributor ID from any place review's reviewer.

## `contributorIds` (type: `array`):

Provide a list of Google Maps contributor IDs to profile in one run. Merged with `contributorId` and de-duplicated. One derived row is returned per reviewer.

## `regionGranularity` (type: `string`):

Level the home-region guess and confidence are computed at: 'city' (e.g. Chicago, IL), 'admin1' (state or province), or 'country'. The row always includes the full standardized breakdown (city, admin, country, ISO codes) regardless. Default 'city'.

## `minCityPopulation` (type: `integer`):

Snap each review to the nearest city with at least this population, so big-metro neighborhoods (e.g. 'Chicago Loop') group under the principal city ('Chicago'). Default 100000. Lower it (e.g. 1000) to keep smaller towns distinct, at the cost of large metros fragmenting across neighborhoods.

## `hl` (type: `string`):

Set the two-letter interface language code (e.g. 'en', 'es', 'de'). Affects the source review text; the region output is standardized independently of this. Defaults to 'en'.

## `maxResultsPerContributor` (type: `integer`):

How many reviews to analyze per contributor, most recent first. Default 100, maximum 200. Deeper history sharpens the home-region signal by diluting a travel-heavy recent window; the analysis cost is the same at any depth. The endpoint returns fewer if the contributor has fewer.

## Actor input object example

```json
{
  "contributorId": "107022004965696773221",
  "regionGranularity": "city",
  "minCityPopulation": 100000,
  "hl": "en",
  "maxResultsPerContributor": 100
}
```

# Actor output Schema

## `results` (type: `string`):

All derived reviewer geo-profile rows stored in the default dataset, one item per reviewer.

# 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 = {
    "contributorId": "107022004965696773221"
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/google-maps-reviewer-geo-profile-api").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 = { "contributorId": "107022004965696773221" }

# Run the Actor and wait for it to finish
run = client.actor("johnvc/google-maps-reviewer-geo-profile-api").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 '{
  "contributorId": "107022004965696773221"
}' |
apify call johnvc/google-maps-reviewer-geo-profile-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=johnvc/google-maps-reviewer-geo-profile-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Reviewer Geo Profile API",
        "description": "Infer a Google Maps reviewer's home region from their review history. Clusters review coordinates into a standardized home-region guess (city/state/country + ISO codes), a confidence score, and a local-vs-travel footprint. One row per reviewer, for reviewer vetting and fraud research. MCP-ready.",
        "version": "0.0",
        "x-build-id": "G5HRwn371TgWx20y9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/johnvc~google-maps-reviewer-geo-profile-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-johnvc-google-maps-reviewer-geo-profile-api",
                "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/johnvc~google-maps-reviewer-geo-profile-api/runs": {
            "post": {
                "operationId": "runs-sync-johnvc-google-maps-reviewer-geo-profile-api",
                "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/johnvc~google-maps-reviewer-geo-profile-api/run-sync": {
            "post": {
                "operationId": "run-sync-johnvc-google-maps-reviewer-geo-profile-api",
                "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": {
                    "contributorId": {
                        "title": "Contributor ID",
                        "type": "string",
                        "description": "Enter a single Google Maps contributor ID (the long numeric ID from a reviewer's profile, e.g. '107022004965696773221'). Provide this, `contributorIds`, or both. You can read a contributor ID from any place review's reviewer."
                    },
                    "contributorIds": {
                        "title": "Contributor IDs",
                        "type": "array",
                        "description": "Provide a list of Google Maps contributor IDs to profile in one run. Merged with `contributorId` and de-duplicated. One derived row is returned per reviewer.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "regionGranularity": {
                        "title": "Region Granularity",
                        "enum": [
                            "city",
                            "admin1",
                            "country"
                        ],
                        "type": "string",
                        "description": "Level the home-region guess and confidence are computed at: 'city' (e.g. Chicago, IL), 'admin1' (state or province), or 'country'. The row always includes the full standardized breakdown (city, admin, country, ISO codes) regardless. Default 'city'.",
                        "default": "city"
                    },
                    "minCityPopulation": {
                        "title": "Minimum City Population",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Snap each review to the nearest city with at least this population, so big-metro neighborhoods (e.g. 'Chicago Loop') group under the principal city ('Chicago'). Default 100000. Lower it (e.g. 1000) to keep smaller towns distinct, at the cost of large metros fragmenting across neighborhoods.",
                        "default": 100000
                    },
                    "hl": {
                        "title": "Language Code",
                        "type": "string",
                        "description": "Set the two-letter interface language code (e.g. 'en', 'es', 'de'). Affects the source review text; the region output is standardized independently of this. Defaults to 'en'.",
                        "default": "en"
                    },
                    "maxResultsPerContributor": {
                        "title": "Maximum Reviews Per Contributor",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many reviews to analyze per contributor, most recent first. Default 100, maximum 200. Deeper history sharpens the home-region signal by diluting a travel-heavy recent window; the analysis cost is the same at any depth. The endpoint returns fewer if the contributor has fewer.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```