# PetSmart Product Reviews Scraper (`automation-lab/petsmart-product-reviews-scraper`) Actor

🐾 Extract public PetSmart product ratings, review text, reviewer context, media, helpfulness, and aggregate rating statistics by product ID.

- **URL**: https://apify.com/automation-lab/petsmart-product-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 review extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## PetSmart Product Reviews Scraper

Collect public PetSmart product reviews as clean, structured data.

Use product IDs from PetSmart URLs and receive review text, star ratings, reviewer context, helpfulness, media, dates, recommendation flags, and product-level rating statistics.

No PetSmart account, browser, cookies, or proxy setup is required.

### What does PetSmart Product Reviews Scraper do?

PetSmart Product Reviews Scraper reads PetSmart's public review feed for one or more products.

It can:

- 🐾 collect reviews for up to 50 product IDs in one run;
- ⭐ filter between minimum and maximum star ratings;
- 📅 filter by submission date;
- 🔃 sort newest, oldest, or most helpful first;
- 🖼️ preserve public review photos and videos;
- 📊 add product review totals and average ratings;
- 🧾 export records to JSON, CSV, Excel, XML, or RSS through Apify.

Each dataset row represents one review.

### Who is it for?

#### Pet brands

Monitor feedback about food, toys, grooming products, and accessories sold through PetSmart.

#### Marketplace and retail teams

Compare customer sentiment, recurring complaints, and launch response across products.

#### Product and quality teams

Feed recent low-star reviews into issue-tracking or voice-of-customer workflows.

#### Consumer researchers

Build reproducible datasets for category, recommendation, rating, and language analysis.

#### Data teams

Schedule collection and load normalized review records into a warehouse or dashboard.

### Why use this PetSmart review extractor?

Manual review collection is slow and difficult to repeat.

This Actor gives you:

- predictable review-level JSON;
- stable product attribution;
- automatic pagination;
- review ID deduplication;
- bounded retry handling;
- optional date and rating boundaries;
- direct source URLs for verification;
- Apify scheduling, API, webhook, and integration support.

The implementation uses a lightweight public JSON route rather than rendering full product pages.

### How to find a PetSmart product ID

Open a PetSmart product page.

Most PetSmart product URLs end with a number before `.html`.

For example:

```text
https://www.petsmart.com/dog/food/.../product-name-1095.html
````

The product ID is:

```text
1095
```

Paste that value into `productIds`.

Use strings so leading zeros are preserved if PetSmart introduces them.

### How to scrape PetSmart product reviews

1. Open the Actor input page.
2. Add one or more values to **PetSmart product IDs**.
3. Choose a small maximum for your first run.
4. Optionally set rating or submission-date filters.
5. Select newest, oldest, or most helpful order.
6. Click **Start**.
7. Open the **Dataset** tab when the run finishes.
8. Preview or download the review records.

The default input collects 20 recent written reviews for product `1095`.

### Input

| Field | Type | Default | Description |
|---|---|---:|---|
| `productIds` | string\[] | `["1095"]` | PetSmart product IDs to collect |
| `maxReviewsPerProduct` | integer | `20` | Maximum matching reviews saved for each product |
| `sort` | string | `newest` | `newest`, `oldest`, or `helpful` |
| `minRating` | integer | none | Minimum star rating from 1 to 5 |
| `maxRating` | integer | none | Maximum star rating from 1 to 5 |
| `submittedAfter` | string | none | ISO date or date-time lower bound |
| `submittedBefore` | string | none | ISO date or date-time upper bound |
| `includeRatingsOnly` | boolean | `false` | Include submissions without written text |

A single run accepts up to 50 product IDs.

### Input examples

#### Recent reviews

```json
{
  "productIds": ["1095"],
  "maxReviewsPerProduct": 50,
  "sort": "newest"
}
```

#### Critical feedback monitor

```json
{
  "productIds": ["1095", "51031"],
  "maxReviewsPerProduct": 200,
  "minRating": 1,
  "maxRating": 3,
  "submittedAfter": "2026-01-01",
  "sort": "newest"
}
```

#### Five-star media research

```json
{
  "productIds": ["1095"],
  "maxReviewsPerProduct": 100,
  "minRating": 5,
  "maxRating": 5,
  "includeRatingsOnly": false
}
```

### Output data

| Field | Description |
|---|---|
| `reviewId` | Stable public review identifier |
| `productId` | PetSmart product identifier |
| `productName` | Product name from the public feed |
| `productUrl` | Canonical product page when available |
| `brand` | Product brand |
| `rating` | Overall star rating |
| `ratingRange` | Maximum rating value, normally 5 |
| `title` | Review headline |
| `text` | Written review body |
| `reviewerNickname` | Public display nickname |
| `reviewerLocation` | Public location when supplied |
| `submittedAt` | Review submission date-time |
| `modifiedAt` | Last public modification date-time |
| `isRecommended` | Whether the reviewer recommends the product |
| `isRatingsOnly` | Whether no written text was submitted |
| `isVerified` | Verified-purchaser badge when exposed |
| `isSyndicated` | Whether the review came from another source |
| `syndicationSource` | Public syndication source when available |
| `helpfulVotes` | Positive feedback votes |
| `unhelpfulVotes` | Negative feedback votes |
| `totalFeedbackVotes` | Total feedback votes |
| `badges` | Public review badges |
| `context` | Public contextual answers |
| `secondaryRatings` | Quality, value, or other sub-ratings |
| `media` | Public photo and video records |
| `productReviewCount` | Product-wide review count |
| `productAverageRating` | Product-wide average rating |
| `matchingReviewCount` | Reviews matching this run's filters |
| `sourceUrl` | Source page for verification |
| `scrapedAt` | UTC extraction timestamp |

### Output example

```json
{
  "reviewId": "252840442",
  "productId": "1095",
  "productName": "Freshpet Vital Grain Free Beef & Bison Adult Dog Food",
  "rating": 5,
  "ratingRange": 5,
  "title": "Fresh Product",
  "text": "I started buying this product a few months ago and my doggo loves it!",
  "reviewerNickname": "Autumn",
  "submittedAt": "2026-07-15T19:10:16.000+00:00",
  "isRatingsOnly": false,
  "isSyndicated": false,
  "helpfulVotes": 0,
  "unhelpfulVotes": 0,
  "totalFeedbackVotes": 0,
  "badges": [],
  "context": {},
  "secondaryRatings": {},
  "media": [],
  "productReviewCount": 803,
  "productAverageRating": 4.74346201743462,
  "matchingReviewCount": 644,
  "sourceUrl": "https://www.petsmart.com/dog/food/...-1095.html",
  "scrapedAt": "2026-07-16T00:00:00.000Z"
}
```

Optional fields are omitted when PetSmart does not publish them.

### How much does it cost to scrape PetSmart reviews?

The Actor uses pay-per-event pricing.

A small one-time start charge covers run initialization, then each saved review is charged as one `review` event.

The BRONZE rate is $0.000022152 per saved review, with tiered rates from $0.000025475 on FREE down to $0.00001 on PLATINUM and DIAMOND, plus a $0.005 start event.

You are not charged a review event for records that are not saved.

Check the live Actor pricing tab for the authoritative rate for your Apify plan.

### Scheduling a PetSmart review monitor

Review monitoring is more useful when repeated.

Create an Apify schedule with:

- a stable list of product IDs;
- `sort` set to `newest`;
- a recent `submittedAfter` value;
- a webhook that forwards completed datasets.

Use `reviewId` as the deduplication key in your destination.

Update the date boundary periodically or deduplicate downstream.

### Integrations

#### Google Sheets

Send new review rows to a shared product or reputation dashboard.

#### Slack or Microsoft Teams

Trigger alerts when low-star reviews appear for monitored products.

#### Zapier and Make

Route review records to support, CRM, or issue-tracking workflows without custom infrastructure.

#### Webhooks

Notify your own service when a scheduled dataset is ready.

#### Data warehouses

Load JSON or CSV exports into BigQuery, Snowflake, Redshift, or PostgreSQL.

### JavaScript API usage

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/petsmart-product-reviews-scraper').call({
  productIds: ['1095'],
  maxReviewsPerProduct: 50,
  sort: 'newest',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API usage

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/petsmart-product-reviews-scraper').call(run_input={
    'productIds': ['1095'],
    'maxReviewsPerProduct': 50,
    'sort': 'newest',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL API usage

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~petsmart-product-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"productIds":["1095"],"maxReviewsPerProduct":50,"sort":"newest"}'
```

Read the returned run object, wait for completion, then fetch its default dataset.

### Use with Apify MCP

#### Claude Code setup

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/petsmart-product-reviews-scraper"
```

#### Claude Desktop setup

Add the server under **Settings → Developer → Edit Config**.

#### Cursor setup

Add the same server under **Settings → Tools & MCP → Add custom MCP**.

#### VS Code setup

Add an HTTP MCP server to your workspace MCP configuration.

Claude Desktop and Cursor can use this `mcpServers` JSON:

```json
{
  "mcpServers": {
    "apify-petsmart-reviews": {
      "url": "https://mcp.apify.com?tools=automation-lab/petsmart-product-reviews-scraper"
    }
  }
}
```

Authorize your Apify account when the client opens the sign-in flow.

Example prompts:

- “Collect the 50 newest reviews for PetSmart product 1095.”
- “Find one- to three-star feedback since January for these product IDs.”
- “Summarize recurring quality complaints and include source review IDs.”
- “Compare average product ratings and recommendation signals.”

MCP results can feed directly into analysis while the full records remain in the Apify dataset.

### Tips for better results

- Start with 20 reviews while validating a product ID.
- Use a date filter for recurring monitors.
- Use `oldest` when creating a historical timeline.
- Use `helpful` to prioritize reviews endorsed by other shoppers.
- Keep rating-only records disabled for text analysis.
- Enable rating-only records for rating-distribution research.
- Store `reviewId` in downstream systems for deduplication.
- Review source URLs before making business decisions.

### Data freshness and completeness

The Actor reads the public review feed available at run time.

Moderation, deletion, syndication, and product-catalog changes are controlled by PetSmart and its review provider.

`matchingReviewCount` reflects the active input filters.

`productReviewCount` can be larger because it represents product-wide aggregate statistics.

Date and rating filters may naturally return no records.

### Limitations

- V1 accepts product IDs, not arbitrary search terms.
- Product URL parsing is not performed automatically.
- Only publicly exposed review fields are returned.
- Some reviews omit text, recommendation, location, badges, or media.
- PetSmart or its review provider can change public client configuration.
- A review removed upstream cannot be recovered by a later run.
- The Actor does not infer sentiment or product quality.

### Is scraping PetSmart reviews legal?

This Actor accesses publicly displayed product-review data.

Public availability does not remove every legal or contractual obligation.

Use the data for a legitimate purpose, collect only what you need, and comply with applicable law, PetSmart's terms, and your organization's policies.

Do not use reviewer information for harassment, identity resolution, discrimination, or unsolicited targeting.

The Actor emits public display nicknames and public context only; it does not request private accounts or credentials.

### Troubleshooting

#### The dataset is empty

Verify the product ID and remove restrictive rating or date filters.

A valid product can also have no matching reviews.

#### The run says the product ID is invalid

Pass only the identifier, not a full URL.

Allowed IDs contain letters, numbers, underscores, or hyphens.

#### `minRating` fails

Use an integer from 1 through 5 and ensure it does not exceed `maxRating`.

#### A date filter fails

Use an ISO value such as `2026-01-01` or `2026-01-01T00:00:00Z`.

#### Counts differ from the product page

The written-review filter excludes rating-only submissions by default, while product-wide totals may include them.

### Related scrapers

Build a broader product-review workflow with other Automation Lab actors:

- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper)
- [Walmart Reviews Scraper](https://apify.com/automation-lab/walmart-reviews-scraper)
- [G2 Reviews & Products Scraper](https://apify.com/automation-lab/g2-scraper)

Use separate source-specific actors because each retailer exposes different identifiers, fields, and collection routes.

### Frequently asked questions

#### Can I collect multiple products in one run?

Yes. Add up to 50 values to `productIds`. The review limit applies separately to each product.

#### Does it require a PetSmart login?

No. The minimum workflow uses a public anonymous review feed.

#### Does it need a proxy?

No proxy is required for the current public API route.

#### Can I retrieve only negative reviews?

Yes. Set `minRating` to 1 and `maxRating` to 2 or 3.

#### Can I retrieve only reviews with text?

Yes. Leave `includeRatingsOnly` set to `false`, which is the default.

#### How do I avoid duplicates?

The Actor deduplicates review IDs during each run. Use `reviewId` to deduplicate across scheduled runs.

#### Can I export to Excel?

Yes. Open the dataset and select Excel, CSV, JSON, XML, or another supported format.

#### Is sentiment analysis included?

No. Export review text to your preferred NLP, LLM, or analytics workflow.

### Support

If a run fails, share the run URL and the non-sensitive portion of your input through the Actor issue form.

Include the affected product ID, expected filter behavior, and whether the product page currently displays reviews.

Do not post Apify tokens or other credentials.

# Actor input Schema

## `productIds` (type: `array`):

Product IDs from PetSmart URLs. For example, the ID in a URL ending in -1095.html is 1095.

## `maxReviewsPerProduct` (type: `integer`):

Stops after this many matching reviews for each product ID.

## `sort` (type: `string`):

Sort matching reviews from newest, oldest, or most helpful.

## `minRating` (type: `integer`):

Only include reviews at or above this star rating.

## `maxRating` (type: `integer`):

Only include reviews at or below this star rating.

## `submittedAfter` (type: `string`):

Optional ISO date or date-time lower bound, such as 2026-01-01.

## `submittedBefore` (type: `string`):

Optional ISO date or date-time upper bound, such as 2026-06-30.

## `includeRatingsOnly` (type: `boolean`):

Include ratings that have no written review text.

## Actor input object example

```json
{
  "productIds": [
    "1095"
  ],
  "maxReviewsPerProduct": 20,
  "sort": "newest",
  "includeRatingsOnly": false
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "productIds": [
        "1095"
    ],
    "maxReviewsPerProduct": 20,
    "sort": "newest",
    "includeRatingsOnly": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/petsmart-product-reviews-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 = {
    "productIds": ["1095"],
    "maxReviewsPerProduct": 20,
    "sort": "newest",
    "includeRatingsOnly": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/petsmart-product-reviews-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 '{
  "productIds": [
    "1095"
  ],
  "maxReviewsPerProduct": 20,
  "sort": "newest",
  "includeRatingsOnly": false
}' |
apify call automation-lab/petsmart-product-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/petsmart-product-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PetSmart Product Reviews Scraper",
        "description": "🐾 Extract public PetSmart product ratings, review text, reviewer context, media, helpfulness, and aggregate rating statistics by product ID.",
        "version": "0.1",
        "x-build-id": "vGwy8fcV9DLoqUggg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~petsmart-product-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-petsmart-product-reviews-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/automation-lab~petsmart-product-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-petsmart-product-reviews-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/automation-lab~petsmart-product-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-petsmart-product-reviews-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": [
                    "productIds"
                ],
                "properties": {
                    "productIds": {
                        "title": "🐾 PetSmart product IDs",
                        "minItems": 1,
                        "maxItems": 50,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Product IDs from PetSmart URLs. For example, the ID in a URL ending in -1095.html is 1095.",
                        "default": [
                            "1095"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "Maximum reviews per product",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stops after this many matching reviews for each product ID.",
                        "default": 20
                    },
                    "sort": {
                        "title": "Review order",
                        "enum": [
                            "newest",
                            "oldest",
                            "helpful"
                        ],
                        "type": "string",
                        "description": "Sort matching reviews from newest, oldest, or most helpful.",
                        "default": "newest"
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only include reviews at or above this star rating."
                    },
                    "maxRating": {
                        "title": "Maximum rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only include reviews at or below this star rating."
                    },
                    "submittedAfter": {
                        "title": "Submitted after",
                        "type": "string",
                        "description": "Optional ISO date or date-time lower bound, such as 2026-01-01."
                    },
                    "submittedBefore": {
                        "title": "Submitted before",
                        "type": "string",
                        "description": "Optional ISO date or date-time upper bound, such as 2026-06-30."
                    },
                    "includeRatingsOnly": {
                        "title": "Include rating-only records",
                        "type": "boolean",
                        "description": "Include ratings that have no written review text.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
