# Yelp Photos Scraper (`beatanalytics/yelp-photos-scraper`) Actor

Download every photo from any Yelp business — the complete gallery, not just the first 30. Get full-resolution image and video URLs, captions, categories, dimensions, dates, and uploader profiles. Search by keyword + location or paste business URLs. Export CSV, JSON, or Excel.

- **URL**: https://apify.com/beatanalytics/yelp-photos-scraper.md
- **Developed by:** [Beat Analytics](https://apify.com/beatanalytics) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 photos

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

### Yelp Photos Scraper — download every photo and video from any Yelp listing

This is the only **dedicated Yelp photo extractor** on Apify. It pulls the **complete** photo set for a business — often **1,000+ images** for popular restaurants and hotels — each with its caption, category, uploader, and full-resolution URL. General Yelp scrapers treat photos as an afterthought and cap out around **30 images** per business; this **Yelp photos scraper** doesn't stop until the gallery does.

Use it to **download all Yelp photos** as a **Yelp image scraper**, a bulk **Yelp photo downloader**, or a **Yelp photo API** alternative — the official Yelp Fusion API returns at most 3 photos per business. Point it at business URLs, Yelp business IDs, or a **search query + location**, filter by category (food, drink, menu, interior, videos), and **scrape Yelp pictures** in seconds — no API key, no OAuth, no image cap.

### Why use this Yelp photos scraper?

- 📸 **Full gallery, no cap** — every photo on the business page, even 1,000+, well past the ~30-image limit of general Yelp scrapers
- 🖼️ **Bulk Yelp image scraper** — download all Yelp photos and pictures across many businesses in one run
- 🏷️ **Rich metadata** — caption, category, uploader, dimensions, and upload date for every shot
- 🔗 **Full-resolution image URLs** — original `o.jpg` links, not compressed thumbnails
- 🎯 **Category filtering** — pull only `food`, `drink`, `menu`, `interior`, or `videos` shots
- 🎥 **Photos *and* videos in one feed** — direct MP4 links, poster thumbnails, and durations
- 📥 **Flexible input** — business URLs, Yelp business IDs, or search query + location
- 👤 **Uploader profiles** (optional) — who posted each shot, with review/photo/friend counts and Elite year
- 🧾 **Clean JSON/CSV/Excel** output, or via API
- 🔑 **No Yelp API key or OAuth** — just add a business URL and run

### What data can you extract with this Yelp photo scraper?

For every photo or video in a business's gallery:

- **business_id** — Yelp business ID
- **business_alias** — Yelp URL slug (e.g. `the-old-fashioned-madison`)
- **business_url** — link to the Yelp business page
- **category** — the media category the gallery was scraped under
- **media_id** — unique photo or video identifier
- **type** — `photo` or `video`
- **caption** — caption describing the media (if any)
- **date** — upload date (ISO 8601)
- **url** — full-resolution photo URL (null for videos)
- **width** / **height** — image dimensions in pixels (null for videos)
- **share_url** — link to the photo or video on Yelp
- **thumbnail_url** — video poster image (null for photos)
- **video_url** — direct MP4 URL (null for photos)
- **duration** — video length in milliseconds (null for photos)
- **user** — uploader profile (name, image, review/photo/friend counts, Elite year), included only when *Include sensitive data* is enabled

### How to download Yelp photos

1. **Create a free Apify account** — sign up at apify.com, no credit card required.
2. **Open the Yelp Photos Scraper** — from the Apify Store or this page, click **Try for free**.
3. **Add your input** — paste one or more Yelp business URLs (or aliases/IDs), or enter a search query + location to scrape every matching business. Optionally set a category and a max number of media items per business.
4. **Run the actor** — click **Start** and watch the gallery stream into the dataset.
5. **Download your data** — export as CSV, JSON, Excel, XML, or HTML from the **Storage** tab.

### Input parameters

| Field | Type | Description |
|---|---|---|
| `searchQueries` | array | Search terms (e.g. `pizza`, `coffee`) to find businesses. Combined with every `searchLocations` entry; each matching business's gallery is scraped. |
| `searchLocations` | array | Locations to search in (e.g. `Madison, WI`). Used together with `searchQueries`. |
| `businessUrls` | array | Yelp business URLs to scrape media for. Use instead of or alongside aliases/IDs and/or search. |
| `businessAliasesOrIds` | array | Business aliases (e.g. `the-old-fashioned-madison`) or IDs. |
| `maxResultsPerSearch` | integer | Max businesses per search query + location combination. Default `10`. |
| `category` | string | Media category slug to filter by, e.g. `food`, `drink`, `menu`, `videos`. Defaults to `all` (the full gallery). Available slugs are business-specific and appear in the output when scraping `all`. |
| `maxPhotos` | integer | Maximum number of photos and videos to fetch per business. Default `0` (the complete gallery). Set a cap to control cost on high-volume businesses. |
| `includeSensitiveData` | boolean | Include uploader personal information (name, profile image, counts, Elite year). Default `false`. |

### Output example

Each dataset item is one photo or video. Example (a photo):

```json
{
  "business_id": "RJNAeNA-209sctUO0dmwuA",
  "business_alias": "the-old-fashioned-madison",
  "business_url": "https://www.yelp.com/biz/the-old-fashioned-madison",
  "category": "all",
  "media_id": "WnuUTbdmPde3zCaBORRrpA",
  "type": "photo",
  "caption": "Cheese curds in poutine",
  "date": "2026-04-25T15:42:37+00:00",
  "url": "https://s3-media0.fl.yelpcdn.com/bphoto/WnuUTbdmPde3zCaBORRrpA/o.jpg",
  "width": 1995,
  "height": 1995,
  "share_url": "https://www.yelp.com/biz_photos/RJNAeNA-209sctUO0dmwuA?select=WnuUTbdmPde3zCaBORRrpA",
  "thumbnail_url": null,
  "video_url": null,
  "duration": null,
  "user": null
}
````

And a video (with *Include sensitive data* enabled):

```json
{
  "business_id": "RJNAeNA-209sctUO0dmwuA",
  "business_alias": "the-old-fashioned-madison",
  "business_url": "https://www.yelp.com/biz/the-old-fashioned-madison",
  "category": "videos",
  "media_id": "h83zxgXSvi4inSQ6POfNeQ",
  "type": "video",
  "caption": null,
  "date": "2025-04-15T18:48:28+00:00",
  "url": null,
  "width": null,
  "height": null,
  "share_url": "https://www.yelp.com/biz_photos/RJNAeNA-209sctUO0dmwuA?select_video=h83zxgXSvi4inSQ6POfNeQ",
  "thumbnail_url": "https://image.mux.com/iKjAMATs00fQeMXek3qWaVZGp7ekDdu700Yxbtx0077sY4/thumbnail.jpg?height=720&time=0",
  "video_url": "https://stream.mux.com/iKjAMATs00fQeMXek3qWaVZGp7ekDdu700Yxbtx0077sY4/high.mp4",
  "duration": 16066,
  "user": {
    "id": "CSQWcZoOuWfX-1iD5HLY_Q",
    "name": "Casey W.",
    "image": "https://s3-media0.fl.yelpcdn.com/photo/V8ixvP1Io44cFCe13rxoJQ/60s.jpg",
    "friendCount": 1,
    "reviewCount": 27,
    "photoCount": 27,
    "eliteYear": null
  }
}
```

Every run is also available as **CSV, Excel, JSON, XML, and HTML** — all automatic Apify export formats, ready for spreadsheets, databases, or downstream pipelines.

### How much does the Yelp photos scraper cost?

This actor is **pay-per-result**: **$2.00 per 1,000 media items** (one photo or video = one result). A typical restaurant gallery of 100 photos costs about $0.20. Apify's **free tier** includes $5 of monthly usage, enough to scrape roughly 2,500 photos before paying anything. You only pay for what you scrape — no subscriptions, no Yelp developer account, no per-seat licensing.

### Use cases

- **Competitive analysis of a location** — search a query + city (e.g. `pizza` in `Chicago, IL`) and audit every rival's photo gallery to compare how they present food, interiors, and ambiance.
- **Menu and dish research** — pull `menu` and `food` photos to catalog offerings and pricing across a market.
- **Listing and gallery building** — source visual content to power directories, aggregators, or travel sites.
- **Training data for computer vision** — build labeled image datasets of dishes, storefronts, and interiors.
- **Brand monitoring** — track which photos customers upload of your business and spot outdated or unflattering images.
- **Real estate and location scouting** — review interior and exterior shots before visiting or leasing.
- **Marketing and social content** — find high-performing user-generated imagery (with proper attribution/permissions).
- **Video content discovery** — extract customer-shot MP4 clips for research or engagement analysis.

### Integrations and API access

Run the actor programmatically with the Apify API or SDKs.

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('beatanalytics/yelp-photos-scraper').call(
    run_input={
        'searchQueries': ['pizza'],
        'searchLocations': ['Chicago, IL'],
        'maxResultsPerSearch': 20,
        'category': 'food',
        'maxPhotos': 200,
    }
)
for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['url'])
```

**JavaScript:**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('beatanalytics/yelp-photos-scraper').call({
    businessUrls: [
        { url: 'https://www.yelp.com/biz/the-old-fashioned-madison' },
    ],
    category: 'food',
    maxPhotos: 200,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((i) => i.url));
```

You can also trigger runs from **Make, Zapier, or n8n**, or wire up **webhooks** to push new media into your own systems automatically.

### Frequently asked questions

#### Can I download all photos from a Yelp business?

Yes — that's the default. With the category left at `all` and `maxPhotos` at `0`, the scraper paginates through every photo and video Yelp exposes for the business. Set `maxPhotos` only if you want to cap the count.

#### Does this scraper get videos too?

Yes. The media feed includes both photos and videos. Each item has a `type` field, and videos come with a `video_url` (direct MP4), a `thumbnail_url` poster, and a `duration`. Filter to `videos` to get only clips.

#### How do I filter photos by category?

Set the `category` input to a slug like `food`, `drink`, `menu`, `interior`, or `outside`. The available slugs differ per business — scrape with `all` first and the categories appear in Yelp's own gallery tabs; the slugs mirror those tabs.

#### Do I need a Yelp API key?

No. Unlike the official Yelp Fusion API, this actor needs no API key, no OAuth, and no Yelp developer account. And where the Fusion API returns at most 3 photos per business, this scraper downloads the full gallery — the only structured way to get every photo and video.

#### How do I find a business's alias or ID?

The alias is the slug in the Yelp URL — for `https://www.yelp.com/biz/the-old-fashioned-madison`, the alias is `the-old-fashioned-madison`. You can paste the full URL, the alias, or the internal business ID; the scraper resolves any of them.

#### Can I scrape multiple businesses at once?

Yes. Add several URLs, aliases, or IDs — or a search query + location — and the actor scrapes each matching business, tagging every media item with its `business_id` and `business_alias`. Businesses reached through more than one input are scraped only once.

#### Can I find businesses by search instead of pasting URLs?

Yes. Enter one or more `searchQueries` (e.g. `pizza`) and `searchLocations` (e.g. `Chicago, IL`); every combination is searched and the full gallery of each result is scraped. Use `maxResultsPerSearch` to control how many businesses per search.

#### Is there a limit on how many photos I can scrape?

No hard cap. Popular restaurants and hotels often have 1,000+ photos, and the scraper paginates through all of them. General Yelp scrapers typically stop at around 30 images per business — this one keeps going until the gallery ends. Use `maxPhotos` if you *want* to limit the count per business.

#### What image resolution do I get?

Photo `url` links point to the **original full-resolution** image (`o.jpg`). You can derive smaller sizes from the same URL if you need thumbnails.

#### Is scraping Yelp photos legal?

The actor collects publicly visible data. You are responsible for how you use it — respect Yelp's terms, copyright, and applicable privacy laws, and obtain permission before republishing user-generated content.

#### What format is the output?

Datasets export to JSON, CSV, Excel, XML, and HTML. Use the format that fits your workflow — spreadsheets for quick review, JSON for pipelines.

#### How much does it cost?

$2.00 per 1,000 media items, with Apify's free monthly tier covering your first runs. See the cost section above.

### Related actors

Building a complete Yelp dataset? Combine this with our other Yelp tools:

- **[Yelp Business Review Scraper](https://apify.com/beatanalytics/yelp-business-review-scraper)** — every review, rating, and owner reply, bypassing the Fusion API's 3-review limit.
- **[Yelp Business Scraper](https://apify.com/beatanalytics/yelp-business-scraper)** — business details and search results with categories, hours, coordinates, and contact info.

# Actor input Schema

## `searchQueries` (type: `array`):

Search query strings to find businesses (e.g. "pizza", "coffee"). Used together with Search locations. All combinations are searched, and every matching business's gallery is scraped.

## `searchLocations` (type: `array`):

Locations to search in (e.g. "Madison, WI", "Chicago, IL"). Used together with Search queries. All combinations are searched.

## `businessUrls` (type: `array`):

Yelp URLs of businesses you wish to retrieve photos and videos for. Can be used instead of or in addition to business aliases or IDs and/or search.

## `businessAliasesOrIds` (type: `array`):

Business aliases (e.g. "the-old-fashioned-madison") or IDs. Can be used instead of or in addition to URLs and/or search.

## `maxResultsPerSearch` (type: `integer`):

Maximum number of businesses to pull per search query + location combination. Each matching business's full gallery is scraped.

## `category` (type: `string`):

Filter media by category slug, e.g. "food", "drink", "menu", or "videos". Leave as "all" to fetch the complete gallery (photos and videos). Available slugs are business-specific and appear in the output when you scrape "all".

## `maxPhotos` (type: `integer`):

Maximum number of photos and videos to fetch per business. Leave at 0 to fetch the complete gallery — popular businesses can have 1,000+ photos, so set a cap to control cost.

## `includeSensitiveData` (type: `boolean`):

Include uploader personal information (name, profile image, review/photo/friend counts, Elite year) in the output.

## Actor input object example

```json
{
  "businessUrls": [
    {
      "url": "https://www.yelp.com/biz/the-old-fashioned-madison"
    }
  ],
  "maxResultsPerSearch": 10,
  "category": "all",
  "maxPhotos": 0,
  "includeSensitiveData": false
}
```

# Actor output Schema

## `photos` (type: `string`):

All scraped photos and videos with URLs, captions, and metadata.

## `csv` (type: `string`):

Photos and videos exported as a CSV file.

# 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 = {
    "businessUrls": [
        {
            "url": "https://www.yelp.com/biz/the-old-fashioned-madison"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("beatanalytics/yelp-photos-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 = { "businessUrls": [{ "url": "https://www.yelp.com/biz/the-old-fashioned-madison" }] }

# Run the Actor and wait for it to finish
run = client.actor("beatanalytics/yelp-photos-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 '{
  "businessUrls": [
    {
      "url": "https://www.yelp.com/biz/the-old-fashioned-madison"
    }
  ]
}' |
apify call beatanalytics/yelp-photos-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yelp Photos Scraper",
        "description": "Download every photo from any Yelp business — the complete gallery, not just the first 30. Get full-resolution image and video URLs, captions, categories, dimensions, dates, and uploader profiles. Search by keyword + location or paste business URLs. Export CSV, JSON, or Excel.",
        "version": "1.0",
        "x-build-id": "WJhEYOO72a0DgGRDu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/beatanalytics~yelp-photos-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-beatanalytics-yelp-photos-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/beatanalytics~yelp-photos-scraper/runs": {
            "post": {
                "operationId": "runs-sync-beatanalytics-yelp-photos-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/beatanalytics~yelp-photos-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-beatanalytics-yelp-photos-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": [
                    "includeSensitiveData"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Search query strings to find businesses (e.g. \"pizza\", \"coffee\"). Used together with Search locations. All combinations are searched, and every matching business's gallery is scraped.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchLocations": {
                        "title": "Search locations",
                        "type": "array",
                        "description": "Locations to search in (e.g. \"Madison, WI\", \"Chicago, IL\"). Used together with Search queries. All combinations are searched.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "businessUrls": {
                        "title": "Business URLs",
                        "type": "array",
                        "description": "Yelp URLs of businesses you wish to retrieve photos and videos for. Can be used instead of or in addition to business aliases or IDs and/or search.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "businessAliasesOrIds": {
                        "title": "Business aliases or IDs",
                        "type": "array",
                        "description": "Business aliases (e.g. \"the-old-fashioned-madison\") or IDs. Can be used instead of or in addition to URLs and/or search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerSearch": {
                        "title": "Max results per search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of businesses to pull per search query + location combination. Each matching business's full gallery is scraped.",
                        "default": 10
                    },
                    "category": {
                        "title": "Media category",
                        "type": "string",
                        "description": "Filter media by category slug, e.g. \"food\", \"drink\", \"menu\", or \"videos\". Leave as \"all\" to fetch the complete gallery (photos and videos). Available slugs are business-specific and appear in the output when you scrape \"all\".",
                        "default": "all"
                    },
                    "maxPhotos": {
                        "title": "Max media per business",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of photos and videos to fetch per business. Leave at 0 to fetch the complete gallery — popular businesses can have 1,000+ photos, so set a cap to control cost.",
                        "default": 0
                    },
                    "includeSensitiveData": {
                        "title": "Include sensitive data",
                        "type": "boolean",
                        "description": "Include uploader personal information (name, profile image, review/photo/friend counts, Elite year) in the output.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
