# Petsmart Product Reviews Scraper (`stealth_mode/petsmart-product-reviews-scraper`) Actor

Scrape detailed customer reviews from PetSmart product pages. Collect ratings, review text, user feedback, photos, videos, and 50+ structured fields—perfect for e-commerce analysis, sentiment monitoring, and product intelligence gathering.

- **URL**: https://apify.com/stealth\_mode/petsmart-product-reviews-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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 Reviews Scraper: Extract Customer Feedback at Scale
---

### What Is PetSmart?

PetSmart is one of the largest pet retail chains in North America, offering live animals, pet supplies, grooming services, and veterinary care. Their product pages feature extensive customer review sections with ratings, photos, videos, and detailed feedback. Manually collecting and analyzing this review data is labor-intensive; the **PetSmart Reviews Scraper** automates the extraction, turning unstructured customer feedback into actionable data for business intelligence.

---

### Overview

The **PetSmart Reviews Scraper** extracts customer reviews from PetSmart product detail pages, capturing comprehensive feedback data including ratings, text, photos, videos, and engagement metrics. It is designed for:

- **E-commerce analysts** tracking product sentiment and customer satisfaction trends
- **Competitor researchers** benchmarking customer feedback against market alternatives
- **Review aggregators** building centralized databases of pet product reviews
- **Sentiment analysts** processing customer feedback for NLP and business intelligence
- **Marketing teams** identifying top-performing products and common pain points

Key strengths include flexible sorting options, customizable result limits, offset pagination for large datasets, and robust error handling.

---

### Input Format & Configuration

The scraper accepts a JSON configuration object with the following parameters:

```json
{
  "urls": [
    "https://www.petsmart.com/fish/live-fish/goldfish-betta-and-more/female-halfmoon-betta-fish-30684.html#bv-reviews-section"
  ],
  "sort_by": "SubmissionTime:desc",
  "offset": 60,
  "ignore_url_failures": true,
  "max_retries_per_url": 2,
  "max_items_per_url": 200
}
````

#### Input Parameters Explained

| Parameter | Type | Description | Example |
|-----------|------|-------------|---------|
| `urls` | Array | Product detail page URLs with review sections. Must include the `#bv-reviews-section` anchor. | `https://www.petsmart.com/[...]/30684.html#bv-reviews-section` |
| `sort_by` | String | Controls review order. Options: `helpfulness:desc,totalpositivefeedbackcount:desc` (Most Helpful), `rating:desc` (High to Low), `rating:asc` (Low to High), `submissionTime:asc` (Oldest First), `submissionTime:desc` (Newest First). | `SubmissionTime:desc` |
| `offset` | Integer | Number of reviews to skip before collecting. Useful for pagination through large review sets. Set to `0` to start from the first review. | `60` (skips first 60 reviews) |
| `ignore_url_failures` | Boolean | If `true`, the scraper continues even if a URL fails. If `false`, it stops on errors. | `true` |
| `max_retries_per_url` | Integer | Number of retry attempts for failed URLs before giving up. | `2` |
| `max_items_per_url` | Integer | Maximum number of reviews to collect per product URL. | `200` |

> **Tip:** Use `sort_by: "helpfulness:desc,totalpositivefeedbackcount:desc"` to prioritize the most useful reviews. Adjust `offset` to explore different review sections of high-volume products.

***

### Output Format & Field Reference

**Example Output Record:**

```json
{
  "id": "221714520",
  "cid": null,
  "source_client": "petsmart",
  "badges": {},
  "badges_order": [],
  "last_moderated_time": "2023-02-25T19:30:10.000+00:00",
  "last_modification_time": "2023-12-21T04:05:24.000+00:00",
  "product_id": "30684",
  "original_product_name": "Female Halfmoon Betta Fish",
  "campaign_id": null,
  "context_data_values_order": [
    "IncentivizedReview"
  ],
  "author_id": "6s076svaf09webh4sg3kx5c47",
  "content_locale": "en_US",
  "is_featured": false,
  "total_inappropriate_feedback_count": 0,
  "total_client_response_count": 0,
  "total_comment_count": 0,
  "rating": 1,
  "is_ratings_only": false,
  "is_recommended": false,
  "total_feedback_count": 3,
  "total_negative_feedback_count": 1,
  "total_positive_feedback_count": 2,
  "moderation_status": "APPROVED",
  "submission_id": "r14830-en__16707915EmmKPKG7sg",
  "submission_time": "2022-12-11T20:45:49.000+00:00",
  "review_text": "I bought this little betta girl because she was living in a dirty green cup. Her fins were clamped. Luckily with clean warm water and some treatment she is now thriving. Sadly the male betta I purchased at the same time was in worse condition and did not make it thru the night. I can only hope this store finds the time to take better care of their livestock.",
  "title": "Green cup",
  "user_nickname": "DebC0636",
  "additional_fields": {},
  "additional_fields_order": [],
  "context_data_values": {
    "incentivized_review": {
      "value": "False",
      "id": "IncentivizedReview"
    }
  },
  "videos": [],
  "pros": null,
  "comment_ids": [],
  "photos": [],
  "user_location": "Sanford, NC",
  "inappropriate_feedback_list": [],
  "secondary_ratings_order": [
    "Quality",
    "Value",
    "PetSatisfaction"
  ],
  "client_responses": [],
  "tag_dimensions": {},
  "product_recommendation_ids": [],
  "is_syndicated": false,
  "rating_range": 5,
  "helpfulness": 0.6666669845581055,
  "secondary_ratings": {
    "quality": {
      "value": 1,
      "id": "Quality",
      "min_label": null,
      "value_label": null,
      "label": null,
      "max_label": null,
      "value_range": 5,
      "display_type": "NORMAL"
    },
    "value": {
      "value": 3,
      "id": "Value",
      "min_label": null,
      "value_label": null,
      "label": null,
      "max_label": null,
      "value_range": 5,
      "display_type": "NORMAL"
    },
    "pet_satisfaction": {
      "value": 1,
      "id": "PetSatisfaction",
      "min_label": null,
      "value_label": null,
      "label": null,
      "max_label": null,
      "value_range": 5,
      "display_type": "NORMAL"
    }
  },
  "cons": null,
  "tag_dimensions_order": [],
  "from_url": "https://www.petsmart.com/fish/live-fish/goldfish-betta-and-more/female-halfmoon-betta-fish-30684.html#bv-reviews-section"
}
```

The scraper returns detailed review records with 50+ fields per item:

#### Core Review Information

| Field | Meaning | Example |
|-------|---------|---------|
| `id` | Unique review identifier in the system | `"abc123xyz"` |
| `submission_id` | Unique submission ID for this review instance | `"sub_456"` |
| `product_id` | ID of the reviewed product | `"30684"` |
| `original_product_name` | Product name as listed at scrape time | `"Female Halfmoon Betta Fish"` |
| `title` | Review headline/title | `"Great fish, arrived healthy"` |
| `review_text` | Full text of the review | Long-form customer feedback |
| `user_nickname` | Reviewer's display name (may be anonymous) | `"PetLover42"` |
| `user_location` | Geographic location of the reviewer | `"California, USA"` |

#### Ratings & Engagement

| Field | Meaning | Example |
|-------|---------|---------|
| `rating` | Overall product rating (typically 1–5 stars) | `4` |
| `is_ratings_only` | `true` if review is a rating with no text | `false` |
| `is_recommended` | Whether reviewer recommends the product | `true` |
| `total_feedback_count` | Total votes on the review (helpful + unhelpful) | `42` |
| `total_positive_feedback_count` | Number of "helpful" votes | `38` |
| `total_negative_feedback_count` | Number of "unhelpful" votes | `4` |
| `helpfulness` | Calculated helpfulness score/ratio | `0.90` |
| `total_inappropriate_feedback_count` | Flagged as inappropriate by users | `0` |

#### Moderation & Status

| Field | Meaning | Example |
|-------|---------|---------|
| `moderation_status` | Review approval status (e.g., approved, pending) | `"APPROVED"` |
| `submission_time` | Timestamp when review was submitted | `"2024-01-15T10:30:00Z"` |
| `last_modification_time` | Last time the review was edited | `"2024-01-16T14:22:00Z"` |
| `last_moderated_time` | Last time moderated by staff | `"2024-01-15T12:00:00Z"` |
| `is_featured` | `true` if pinned/featured on product page | `true` |
| `is_syndicated` | `true` if review appears on other platforms | `false` |

#### Media & Attachments

| Field | Meaning | Example |
|-------|---------|---------|
| `photos` | Array of photo URLs uploaded with the review | `["https://cdn.../photo1.jpg", "https://cdn.../photo2.jpg"]` |
| `videos` | Array of video URLs/embeds | `["https://youtube.com/watch?v=..."]` |
| `pros` | Positive aspects highlighted by reviewer | `["Vibrant colors", "Active personality"]` |
| `cons` | Negative aspects mentioned | `["High shipping cost"]` |

#### Secondary Data & Classifications

| Field | Meaning | Example |
|-------|---------|---------|
| `secondary_ratings` | Additional attribute ratings (e.g., durability, quality) | `{"durability": 4, "value": 3}` |
| `tag_dimensions` | Product attribute tags applied by reviewer | `["hardy", "beginner-friendly", "peaceful"]` |
| `context_data_values` | Additional metadata fields | Custom key-value pairs |
| `additional_fields` | Extended review fields (varies by product category) | Category-specific data |
| `badges` | Special badges earned (e.g., "Verified Purchase") | `["Verified Purchase", "Expert Reviewer"]` |

#### Client & Campaign Data

| Field | Meaning | Example |
|-------|---------|---------|
| `author_id` | Internal user/author ID | `"user_789"` |
| `cid` | Customer/client identifier | `"cust_001"` |
| `campaign_id` | Associated marketing campaign | `"campaign_q1_2024"` |
| `source_client` | Which platform/client generated the review | `"petsmart.com"` |
| `content_locale` | Language/locale of the review | `"en_US"` |

#### Engagement & Community Features

| Field | Meaning | Example |
|-------|---------|---------|
| `total_client_response_count` | Number of responses from PetSmart/seller | `1` |
| `client_responses` | Array of official responses to the review | Seller/brand replies |
| `total_comment_count` | User comments on the review | `3` |
| `comment_ids` | IDs of associated comments | `["cmt_001", "cmt_002"]` |
| `product_recommendation_ids` | IDs of recommended products | Product IDs from review |

#### Additional Attributes

| Field | Meaning |
|-------|---------|
| `rating_range` | Scale range for ratings (typically 1–5) |
| `secondary_ratings_order` | Order of secondary rating fields |
| `tag_dimensions_order` | Sort order for tag dimensions |
| `badges_order` | Display order for badges |
| `context_data_values_order` | Order of context data elements |
| `additional_fields_order` | Order of additional custom fields |

***

### How to Use the Scraper

1. **Locate product URLs** — Navigate to PetSmart.com, find a product, scroll to the reviews section, and copy the URL. Ensure it includes `#bv-reviews-section` for proper anchor linking.

2. **Configure input parameters:**
   - Paste product URLs into the `urls` array
   - Choose a `sort_by` option (e.g., `submissionTime:desc` for newest first)
   - Set `offset: 0` to start from the beginning, or use `offset: 60` to skip the first 60 reviews
   - Set `max_items_per_url` to your desired limit (max 200 per URL)

3. **Start the scraper** — Execute the run and monitor progress via logs.

4. **Handle pagination** — For products with hundreds of reviews, use `offset` to paginate in chunks (e.g., `offset: 0`, then `offset: 200`, then `offset: 400`).

5. **Export results** — Download scraped data as JSON, CSV, or Excel for analysis.

**Best practices:**

- Use `ignore_url_failures: true` for bulk runs to prevent interruptions.
- Start with `max_items_per_url: 50` to test, then increase as needed.
- Sort by helpfulness if you need the most valuable feedback first.
- Include `max_retries_per_url: 2` to handle temporary network issues.

**Troubleshooting:**

- If no reviews appear, verify the URL ends with `#bv-reviews-section`.
- If the scraper returns empty results, the product may have no reviews yet.
- Check the `moderation_status` field—only `APPROVED` reviews are public.

***

### Use Cases & Business Applications

- **Sentiment analysis:** Process review text with NLP tools to identify trends and pain points
- **Competitive intelligence:** Compare customer feedback across competing pet products
- **Product development:** Identify which features customers praise or criticize most
- **Review aggregation:** Feed PetSmart reviews into unified review platforms
- **Customer insight:** Analyze ratings distribution and identify high-risk products with low scores
- **Marketing insights:** Identify top-rated products and testimonial opportunities

The PetSmart Reviews Scraper transforms scattered customer opinions into structured, analyzable datasets that drive smarter product and business decisions.

***

### Conclusion

The **PetSmart Reviews Scraper** unlocks the full value of customer feedback at scale. With 50+ data fields covering ratings, text, media, engagement, and metadata, it provides everything needed for comprehensive review analysis. Whether you're building a review aggregator, analyzing product sentiment, or conducting competitive research, this scraper streamlines data collection and saves hours of manual work.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the product details urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `sort_by` (type: `string`):

Sort Items by

## `offset` (type: `integer`):

Offset

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.petsmart.com/fish/live-fish/goldfish-betta-and-more/female-halfmoon-betta-fish-30684.html#bv-reviews-section"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.petsmart.com/fish/live-fish/goldfish-betta-and-more/female-halfmoon-betta-fish-30684.html#bv-reviews-section"
    ],
    "offset": 0,
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/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 = {
    "urls": ["https://www.petsmart.com/fish/live-fish/goldfish-betta-and-more/female-halfmoon-betta-fish-30684.html#bv-reviews-section"],
    "offset": 0,
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/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 '{
  "urls": [
    "https://www.petsmart.com/fish/live-fish/goldfish-betta-and-more/female-halfmoon-betta-fish-30684.html#bv-reviews-section"
  ],
  "offset": 0,
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/petsmart-product-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Petsmart Product Reviews Scraper",
        "description": "Scrape detailed customer reviews from PetSmart product pages. Collect ratings, review text, user feedback, photos, videos, and 50+ structured fields—perfect for e-commerce analysis, sentiment monitoring, and product intelligence gathering.",
        "version": "0.0",
        "x-build-id": "pot1IDVV9vPqKudLJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~petsmart-product-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-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/stealth_mode~petsmart-product-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-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/stealth_mode~petsmart-product-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-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",
                "properties": {
                    "urls": {
                        "title": "URLs of the product details urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the product details urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort_by": {
                        "title": "Sort by",
                        "enum": [
                            "",
                            "helpfulness:desc,totalpositivefeedbackcount:desc",
                            "rating:desc",
                            "rating:asc",
                            "submissionTime:asc",
                            "submissionTime:desc"
                        ],
                        "type": "string",
                        "description": "Sort Items by"
                    },
                    "offset": {
                        "title": "Offset",
                        "type": "integer",
                        "description": "Offset"
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
