# Google Maps Photos & Videos Scraper (`lurkapi/google-maps-photos-and-videos-scraper`) Actor

Extract every photo and video for any Google Maps place, categorized as Menu, Food & drink, Vibe, By owner, Latest, Videos, and Street View.

- **URL**: https://apify.com/lurkapi/google-maps-photos-and-videos-scraper.md
- **Developed by:** [LurkAPI](https://apify.com/lurkapi) (community)
- **Categories:** Automation, Videos, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.25 / 1,000 photo or video extracteds

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 Photos & Videos Scraper

Extract every photo and every video for any Google Maps place, sorted by category (Menu, Food & drink, Vibe, By owner, Latest, Videos, Street View & 360°).

### 🎬 What it does

Paste one or more Google Maps places, and the Actor returns one row per photo:

1. Resolves each input (URL, share link, place_id, or hex CID) to a place.
2. Pulls the photo list for every category you selected, paginating until done.
3. Returns each photo's CDN URL, dimensions, GPS coordinates, upload date, and uploader source.

### 📋 How to use it

#### Step 1: Pick how you want to find places

Two ways, use either or both:

**A. Paste place URLs / IDs.** Drop one or more places into the **Place URLs or IDs** field. Any of these shapes work:
- **Google Maps URL** copied from the address bar.
- **Share link** from the desktop or mobile "Share" button (`maps.app.goo.gl/...`).
- **place_id:** form (`place_id:ChIJ...`).
- **Hex CID** (`0x...:0x...`).

**B. Search by keyword.** Type one or more keywords into **Search keywords** and either:
- a **Location** like `Paris, France` (city / region / country), or
- a **Search circle** for a precise radius — `{"lat": 48.86, "lng": 2.35, "radiusMiles": 5}`, or
- a **Search polygon** for an arbitrary area — `[[2.32, 48.85], [2.40, 48.85], [2.40, 48.90], [2.32, 48.90]]`.

Set **Max places per search keyword** to cap how many results each keyword surfaces (Google's hard cap is ~120 per query).

#### Step 2: Pick categories

By default the Actor scrapes every supported tab. To trim cost on places with thousands of photos, pick a subset (e.g. only `Menu` for restaurant menu audits, or only `Videos` for video discovery).

#### Step 3: Run it

Click **Start**. Results appear in the Output tab as they're scraped, batched by page.

#### Step 4: Get your results

Each row contains:

| Field | What it is |
|---|---|
| `photoId` | Google's stable photo identifier |
| `type` | `photo`, `video`, or `street_view` |
| `categoryLabel` | The Maps tab the photo came from |
| `imageUrl` | Full CDN URL at your selected resolution |
| `thumbnailUrl` | Original 200-wide thumbnail URL |
| `width`, `height` | Original pixel dimensions |
| `latitude`, `longitude` | GPS coordinates from EXIF (when available) |
| `uploadDate` | ISO date the photo was posted |
| `uploadedByOwner` | True when the place owner uploaded it |
| `source` | Upload source (`android`, `ios`, `web`, `owner`) |
| `placeId`, `placeName`, `placeUrl` | Identifying the place |

A `status` field tells you whether the row succeeded or what went wrong.

### 💰 Pricing

- **$0.25 per 1,000 photos** scraped (`photo-scraped` event).
- **$5 per 1,000 places** surfaced by a search keyword (`search-place-found` event). Direct URL inputs do not trigger this charge.
- Rows that report a parsing failure or "no photos" are **not charged**.

Examples:

- 1,000 photos → $0.25
- 10,000 photos → $2.50
- 100,000 photos → $25
- 500,000 photos → $125

### 💡 Good to know

- Image URLs come from Google's CDN. Larger sizes cost the same, the CDN does the resize for free.
- Photos are deduplicated by `photoId` across categories: a photo that appears in both "Latest" and "Menu" is only billed once.
- Per-category caps apply with **Max photos per place**; set it small for a preview, raise it for full collection.

### ❓ FAQ

**Why are some photos missing GPS coordinates?**

Google strips EXIF GPS data from many uploads. Coordinates are only present for ~30% of typical photos.

**Why did one place return no photos?**

Either the place has no public photos, or Google rate-limited the session for that place. Re-running usually resolves it.

**How long are results stored?**

Stored in your Apify storage. Retention depends on your Apify plan.

### 🔗 Other tools you might like

- [Google Maps Reviews Scraper](https://apify.com/lurkapi/google-maps-reviews-scraper): Extract reviews with text, owner replies, rating, and date.
- [Google Maps Business Leads Scraper](https://apify.com/lurkapi/google-maps-business-leads-scraper): Scrape places + enrich with emails, phones, and social profiles.

### ⚖️ Disclaimer

This tool is for educational and market research purposes only. It extracts strictly public, non-personally identifiable commercial data. The developer does not host, store, or have possession of any data extracted by the user.

By running this tool, you assume 100% responsibility for compliance with local laws and Google's Terms of Service. The developer assumes zero liability for any platform blocks, account bans, or legal actions resulting from your use of this software.

**Keywords:** google maps photos, google maps videos, maps scraper, place photo download, restaurant menu photos, street view scraper

# Actor input Schema

## `startUrls` (type: `array`):

One or more places to scrape photos for. Supported shapes:
• Full Google Maps URL (paste from the address bar or 'Copy link')
• Share link (maps.app.goo.gl / goo.gl/maps)
• place_id:ChIJ... URL
• Hex CID (0x...:0x...)

Either this OR the search-term fields below must be provided.
## `searchTerms` (type: `array`):

Search keywords to find places by. Each keyword runs as a Google Maps search; every matching place gets photos scraped. Combine with 'Location', 'Search circle', or 'Search polygon' below.
## `location` (type: `string`):

City, region, or country to search in. A city name alone works ('Paris'); add a country for precision ('Paris, France'). Ignored if 'searchCircle' or 'searchPolygon' is also set.
## `maxPlacesPerSearch` (type: `integer`):

Cap on how many places one search keyword surfaces before photo scraping begins. Google's hard cap is ~120 per query.
## `searchCircle` (type: `object`):

Limit search keywords to a circular area. Provide JSON like `{ "lat": 48.86, "lng": 2.35, "radiusMiles": 5 }`. Overrides 'Location' when set.
## `searchPolygon` (type: `array`):

Limit search keywords to a polygon. Provide JSON like `[[2.32, 48.85], [2.40, 48.85], [2.40, 48.90], [2.32, 48.90]]` (≥3 [lng, lat] vertices). Overrides 'Location' and 'Search circle' when set.
## `categories` (type: `array`):

Which photo tabs to include. Pick 'all' to scrape every tab. Tabs not present on a given place are skipped automatically.
## `maxPhotosPerPlace` (type: `integer`):

Stop paginating each tab once this many photos have been returned. Set to a small number for previews; raise it (or omit) for full collection.
## `imageSize` (type: `string`):

Suffix applied to the image URL. Larger sizes cost the same in this Actor — Google's CDN serves the resize for free.
## `outputType` (type: `boolean`):

Whether the entry is a photo, video, or Street View panorama.
## `outputCategory` (type: `boolean`):

The Maps tab the photo came from (key like 'food', label like 'Food & drink').
## `outputThumbnailUrl` (type: `boolean`):

Small preview URL (~200px), alongside the full-size image URL.
## `outputDimensions` (type: `boolean`):

Original pixel dimensions of the photo or video frame.
## `outputGps` (type: `boolean`):

GPS EXIF data when present. Stripped from ~70% of user uploads.
## `outputUploadDate` (type: `boolean`):

Date the photo was posted to Google Maps.
## `outputUploadedByOwner` (type: `boolean`):

True when the place owner posted the photo via Google My Business.
## `outputSource` (type: `boolean`):

Normalized source platform the photo was uploaded from.
## `outputPlaceName` (type: `boolean`):

Human-readable place name extracted from the input URL.
## `outputPlaceUrl` (type: `boolean`):

The original URL the user provided for this place.
## `outputPlaceIds` (type: `boolean`):

Stable Google identifiers for the place. Useful when feeding rows into other Maps tools.
## `outputSearchKeyword` (type: `boolean`):

When the place was surfaced from a search keyword (not a direct URL), include which keyword produced it.
## `outputInternalCategoryCode` (type: `boolean`):

Google's numeric per-photo category tag. Mostly useful for debugging.
## `outputScrapedAt` (type: `boolean`):

ISO 8601 timestamp of when the row was extracted.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.google.com/maps/place/Eiffel+Tower/@48.8583701,2.2944813,17z/data=!4m6!3m5!1s0x47e66e2964e34e2d:0x8ddca9ee380ef7e0!8m2!3d48.8583701!4d2.2944813!16zL20vMDJqODE"
  ],
  "searchTerms": [],
  "location": "",
  "maxPlacesPerSearch": 5,
  "searchPolygon": [],
  "categories": [
    "all"
  ],
  "maxPhotosPerPlace": 20,
  "imageSize": "large",
  "outputType": true,
  "outputCategory": true,
  "outputThumbnailUrl": true,
  "outputDimensions": true,
  "outputGps": true,
  "outputUploadDate": true,
  "outputUploadedByOwner": true,
  "outputSource": true,
  "outputPlaceName": true,
  "outputPlaceUrl": true,
  "outputPlaceIds": true,
  "outputSearchKeyword": true,
  "outputInternalCategoryCode": false,
  "outputScrapedAt": true
}
````

# Actor output Schema

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

All photos and videos with thumbnail, place, and category.

## `byCategory` (type: `string`):

Photos and videos grouped by Maps category.

## `media` (type: `string`):

Image and video URLs with original dimensions.

# 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 = {
    "startUrls": [
        "https://www.google.com/maps/place/Eiffel+Tower/@48.8583701,2.2944813,17z/data=!4m6!3m5!1s0x47e66e2964e34e2d:0x8ddca9ee380ef7e0!8m2!3d48.8583701!4d2.2944813!16zL20vMDJqODE"
    ],
    "maxPlacesPerSearch": 5,
    "categories": [
        "all"
    ],
    "maxPhotosPerPlace": 20,
    "imageSize": "large"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lurkapi/google-maps-photos-and-videos-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": ["https://www.google.com/maps/place/Eiffel+Tower/@48.8583701,2.2944813,17z/data=!4m6!3m5!1s0x47e66e2964e34e2d:0x8ddca9ee380ef7e0!8m2!3d48.8583701!4d2.2944813!16zL20vMDJqODE"],
    "maxPlacesPerSearch": 5,
    "categories": ["all"],
    "maxPhotosPerPlace": 20,
    "imageSize": "large",
}

# Run the Actor and wait for it to finish
run = client.actor("lurkapi/google-maps-photos-and-videos-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.google.com/maps/place/Eiffel+Tower/@48.8583701,2.2944813,17z/data=!4m6!3m5!1s0x47e66e2964e34e2d:0x8ddca9ee380ef7e0!8m2!3d48.8583701!4d2.2944813!16zL20vMDJqODE"
  ],
  "maxPlacesPerSearch": 5,
  "categories": [
    "all"
  ],
  "maxPhotosPerPlace": 20,
  "imageSize": "large"
}' |
apify call lurkapi/google-maps-photos-and-videos-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Photos & Videos Scraper",
        "description": "Extract every photo and video for any Google Maps place, categorized as Menu, Food & drink, Vibe, By owner, Latest, Videos, and Street View.",
        "version": "0.0",
        "x-build-id": "jq5xGuvbA9s1n5Lc9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lurkapi~google-maps-photos-and-videos-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lurkapi-google-maps-photos-and-videos-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/lurkapi~google-maps-photos-and-videos-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lurkapi-google-maps-photos-and-videos-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/lurkapi~google-maps-photos-and-videos-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lurkapi-google-maps-photos-and-videos-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Place URLs or IDs",
                        "type": "array",
                        "description": "One or more places to scrape photos for. Supported shapes:\n• Full Google Maps URL (paste from the address bar or 'Copy link')\n• Share link (maps.app.goo.gl / goo.gl/maps)\n• place_id:ChIJ... URL\n• Hex CID (0x...:0x...)\n\nEither this OR the search-term fields below must be provided.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "searchTerms": {
                        "title": "Search keywords (alternative to URLs)",
                        "type": "array",
                        "description": "Search keywords to find places by. Each keyword runs as a Google Maps search; every matching place gets photos scraped. Combine with 'Location', 'Search circle', or 'Search polygon' below.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "location": {
                        "title": "Location (for search keywords)",
                        "type": "string",
                        "description": "City, region, or country to search in. A city name alone works ('Paris'); add a country for precision ('Paris, France'). Ignored if 'searchCircle' or 'searchPolygon' is also set.",
                        "default": ""
                    },
                    "maxPlacesPerSearch": {
                        "title": "Max places per search keyword",
                        "minimum": 1,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Cap on how many places one search keyword surfaces before photo scraping begins. Google's hard cap is ~120 per query.",
                        "default": 20
                    },
                    "searchCircle": {
                        "title": "Search circle (lat / lng / radiusMiles)",
                        "type": "object",
                        "description": "Limit search keywords to a circular area. Provide JSON like `{ \"lat\": 48.86, \"lng\": 2.35, \"radiusMiles\": 5 }`. Overrides 'Location' when set."
                    },
                    "searchPolygon": {
                        "title": "Search polygon ([lng, lat] pairs)",
                        "type": "array",
                        "description": "Limit search keywords to a polygon. Provide JSON like `[[2.32, 48.85], [2.40, 48.85], [2.40, 48.90], [2.32, 48.90]]` (≥3 [lng, lat] vertices). Overrides 'Location' and 'Search circle' when set.",
                        "items": {
                            "type": "array",
                            "items": {
                                "type": "number"
                            }
                        },
                        "default": []
                    },
                    "categories": {
                        "title": "Categories to scrape",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which photo tabs to include. Pick 'all' to scrape every tab. Tabs not present on a given place are skipped automatically.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "all",
                                "menu",
                                "food",
                                "vibe",
                                "by_owner",
                                "latest",
                                "videos",
                                "street_view"
                            ],
                            "enumTitles": [
                                "All photos",
                                "Menu",
                                "Food & drink",
                                "Vibe",
                                "By owner",
                                "Latest",
                                "Videos",
                                "Street View & 360°"
                            ]
                        },
                        "default": [
                            "all"
                        ]
                    },
                    "maxPhotosPerPlace": {
                        "title": "Max photos per place (per category)",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop paginating each tab once this many photos have been returned. Set to a small number for previews; raise it (or omit) for full collection.",
                        "default": 200
                    },
                    "imageSize": {
                        "title": "Image resolution",
                        "enum": [
                            "thumbnail",
                            "medium",
                            "large",
                            "original"
                        ],
                        "type": "string",
                        "description": "Suffix applied to the image URL. Larger sizes cost the same in this Actor — Google's CDN serves the resize for free.",
                        "default": "large"
                    },
                    "outputType": {
                        "title": "Media type",
                        "type": "boolean",
                        "description": "Whether the entry is a photo, video, or Street View panorama.",
                        "default": true
                    },
                    "outputCategory": {
                        "title": "Category (key + label)",
                        "type": "boolean",
                        "description": "The Maps tab the photo came from (key like 'food', label like 'Food & drink').",
                        "default": true
                    },
                    "outputThumbnailUrl": {
                        "title": "Thumbnail URL",
                        "type": "boolean",
                        "description": "Small preview URL (~200px), alongside the full-size image URL.",
                        "default": true
                    },
                    "outputDimensions": {
                        "title": "Original dimensions (width × height)",
                        "type": "boolean",
                        "description": "Original pixel dimensions of the photo or video frame.",
                        "default": true
                    },
                    "outputGps": {
                        "title": "GPS coordinates (latitude / longitude)",
                        "type": "boolean",
                        "description": "GPS EXIF data when present. Stripped from ~70% of user uploads.",
                        "default": true
                    },
                    "outputUploadDate": {
                        "title": "Upload date (ISO 8601)",
                        "type": "boolean",
                        "description": "Date the photo was posted to Google Maps.",
                        "default": true
                    },
                    "outputUploadedByOwner": {
                        "title": "Uploaded-by-owner flag",
                        "type": "boolean",
                        "description": "True when the place owner posted the photo via Google My Business.",
                        "default": true
                    },
                    "outputSource": {
                        "title": "Upload source (android / ios / web / owner)",
                        "type": "boolean",
                        "description": "Normalized source platform the photo was uploaded from.",
                        "default": true
                    },
                    "outputPlaceName": {
                        "title": "Place name",
                        "type": "boolean",
                        "description": "Human-readable place name extracted from the input URL.",
                        "default": true
                    },
                    "outputPlaceUrl": {
                        "title": "Place URL (input)",
                        "type": "boolean",
                        "description": "The original URL the user provided for this place.",
                        "default": true
                    },
                    "outputPlaceIds": {
                        "title": "Place identifiers (FID + KG entity + place_id)",
                        "type": "boolean",
                        "description": "Stable Google identifiers for the place. Useful when feeding rows into other Maps tools.",
                        "default": true
                    },
                    "outputSearchKeyword": {
                        "title": "Source search keyword",
                        "type": "boolean",
                        "description": "When the place was surfaced from a search keyword (not a direct URL), include which keyword produced it.",
                        "default": true
                    },
                    "outputInternalCategoryCode": {
                        "title": "Internal category code (advanced)",
                        "type": "boolean",
                        "description": "Google's numeric per-photo category tag. Mostly useful for debugging.",
                        "default": false
                    },
                    "outputScrapedAt": {
                        "title": "Scrape timestamp",
                        "type": "boolean",
                        "description": "ISO 8601 timestamp of when the row was extracted.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```