# Vitacost Product Reviews Scraper (`automation-lab/vitacost-product-reviews-scraper`) Actor

💊 Export public Vitacost product reviews, ratings, buyer details, helpfulness, media, replies, and sentiment summaries for supplement research.

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

## Pricing

Pay per event

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## Vitacost Product Reviews Scraper

Extract public **Vitacost product reviews** into structured JSON, CSV, Excel, or API-ready datasets.

Turn product pages into rows containing review text, star ratings, buyer verification, dates, helpful votes, media, replies, transparency signals, and product-level rating summaries.

Use the actor for supplement sentiment research, quality monitoring, competitive intelligence, voice-of-customer analysis, and recurring review alerts.

### What does Vitacost Product Reviews Scraper do?

The actor accepts Vitacost product URLs or numeric product IDs.

It resolves each product, reads its public review summary, follows all required review pages, and saves one row per review.

Each row is self-contained and includes:

- ⭐ Star rating and review title
- 💬 Plain text and original HTML body
- 👤 Public reviewer name and review date
- ✅ Verified-buyer and anonymous-reviewer flags
- 👍 Helpful and unhelpful vote counts
- 🖼️ Public review pictures and videos
- 🏷️ Syndication source and transparency badges
- 📝 Recommendation answers and merchant replies
- 📦 Product ID, name, URL, and image
- 📊 Average rating, review count, and star histogram

### Who is it for?

#### Supplement and CPG brands

Track customer language around efficacy, taste, packaging, dosage, delivery, and repeat purchase intent.

#### Marketplace sellers

Compare customer feedback across competing products before choosing inventory, positioning, or bundles.

#### Consumer-insights teams

Build review corpora for topic modeling, sentiment classification, complaint taxonomy, and trend analysis.

#### Agencies

Create recurring client reports without copying review pages manually.

#### Product and quality teams

Monitor newest low-star feedback for emerging defects, packaging failures, or expectation gaps.

### Why use this Vitacost review extractor?

Manual review collection is slow and difficult to reproduce.

This actor provides stable review UUIDs for deduplication and repeat monitoring.

It uses public structured review data instead of brittle visual page automation.

Benefits include:

- Fast HTTP-only extraction
- No Vitacost login required
- URL and product-ID inputs
- Automatic pagination
- Stable review UUID deduplication
- Rating and verified-buyer filters
- Predictable per-review pricing
- Apify datasets, webhooks, schedules, API, and integrations

### What data can you extract?

| Field | Description |
|---|---|
| `reviewId` | Stable public review UUID |
| `title` | Review headline |
| `body` | Clean plain-text review |
| `bodyHtml` | Original public review HTML |
| `rating` | One-to-five star score |
| `reviewerName` | Public display name |
| `reviewDate` | ISO review timestamp |
| `verifiedBuyer` | Verified-purchase marker |
| `anonymousReviewer` | Anonymous reviewer marker |
| `source` | Syndicated source when disclosed |
| `transparencyBadges` | Public provenance labels |
| `recommendation` | Recommendation answer when present |
| `customAnswers` | Other public review-form answers |
| `reply` | Merchant reply when present |
| `helpfulVotes` | Helpful vote count |
| `unhelpfulVotes` | Unhelpful vote count |
| `pictures` | Public review image URLs |
| `videos` | Public review video identifiers |
| `productId` | Vitacost/Judge.me product ID |
| `productName` | Product title |
| `productUrl` | Canonical product URL when available |
| `productImageUrl` | Main product image |
| `averageRating` | Current product average |
| `reviewCount` | Current public review count |
| `ratingHistogram` | Counts and percentages by star |
| `scrapedAt` | UTC extraction time |

### How to scrape Vitacost reviews

1. Open the actor in Apify Console.
2. Add one or more Vitacost product URLs.
3. Optionally add numeric product IDs.
4. Set the maximum reviews per product.
5. Choose rating or verified-buyer filters.
6. Select newest, highest-rating, or lowest-rating order.
7. Click **Start**.
8. Export the dataset as JSON, CSV, Excel, XML, or RSS.

A prefilled run collects only 10 reviews, making the first test quick and inexpensive.

### Input

```json
{
  "startUrls": [
    {
      "url": "https://www.vitacost.com/products/vitacost-vitamin-d3-mini-gels-125-mcg-5-000-iu-365-softgels-158727"
    }
  ],
  "maxReviewsPerProduct": 100,
  "ratings": [1, 2, 3, 4, 5],
  "verifiedOnly": false,
  "sortBy": "newest"
}
````

You may combine URLs and IDs in one run.

Supported URLs must begin with `https://www.vitacost.com/products/`.

Invalid domains and non-product paths fail closed.

### Input options

#### Vitacost product URLs

Use current product-detail URLs copied from Vitacost.

Tracking query parameters and fragments are removed automatically.

#### Product IDs

Use 8–20 digit product IDs when you already have catalog identifiers.

The actor verifies that the response product ID matches the requested ID.

#### Maximum reviews per product

Set a separate cap for each supplied product.

Use 10–50 for quick research and a larger limit for full-history analysis.

#### Ratings

Keep any combination of one through five stars.

Leave the list empty to collect all ratings.

#### Verified buyers only

Enable this option to retain reviews carrying a public verified-purchase marker.

#### Review order

Choose newest first for monitoring, highest first for advocacy research, or lowest first for issue discovery.

### Output example

```json
{
  "reviewId": "2cd2ec3f-55c7-4426-a24d-f4dabc59c8df",
  "title": "A must Vit",
  "body": "Everyone needs a good D3...",
  "rating": 5,
  "reviewerName": "Manaman850",
  "reviewDate": "2025-12-18T09:07:21.000Z",
  "verifiedBuyer": false,
  "recommendation": "Yes",
  "helpfulVotes": 0,
  "productId": "10390054928699",
  "productName": "Vitacost, Vitamin D3 Mini Gels, 125 mcg (5,000 IU), 365 Softgels",
  "averageRating": 4.84,
  "reviewCount": 425
}
```

Fields remain typed and stable across URL and ID inputs.

### How much does it cost to scrape Vitacost product reviews?

This actor uses pay-per-event pricing.

A small one-time start charge covers run initialization.

You then pay only for review rows saved to the dataset.

The current base prices are **$0.005 per run start** and **$0.000047578 per review** on the Bronze tier, with lower per-review prices on larger Apify plans.

The input cap gives you direct control over total spend.

Apify shows an estimated and final charge for each run.

### Review monitoring workflow

Schedule the actor daily or weekly with `sortBy` set to `newest`.

Store previously seen `reviewId` values in your database.

On each run:

1. Fetch the newest reviews.
2. Ignore UUIDs already stored.
3. Alert on new one- or two-star reviews.
4. Route high-priority complaints to quality or support teams.
5. Aggregate repeated themes in your BI system.

### Sentiment analysis workflow

Export `title`, `body`, `rating`, and `recommendation` to your NLP pipeline.

Use rating as a weak supervision label.

Group sentiment by product, date, source, or verified-buyer status.

The `transparencyBadges` and `source` fields help distinguish syndicated feedback from direct submissions.

### Competitor research workflow

Run the same review cap for multiple products.

Compare:

- Average rating and review volume
- Star-rating distributions
- Common complaint phrases
- Recommendation rates
- Helpful negative reviews
- New feedback velocity
- Syndicated-review provenance

Repeat on a schedule to detect product launches or quality shifts.

### Integrations

#### Google Sheets

Use Apify's Google Sheets integration to append review rows to a shared research workbook.

#### Slack and email

Trigger a webhook when a run finishes, then alert on new low-star UUIDs.

#### Make and Zapier

Connect dataset items to CRM, support, reporting, or content-classification workflows.

#### BigQuery and data warehouses

Load normalized review rows for time-series and cross-product analysis.

#### Webhooks

Send run completion events to your API and fetch the default dataset by run ID.

### Run from the Apify API with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/vitacost-product-reviews-scraper').call({
  startUrls: [{ url: 'https://www.vitacost.com/products/vitacost-vitamin-d3-mini-gels-125-mcg-5-000-iu-365-softgels-158727' }],
  maxReviewsPerProduct: 50,
  sortBy: 'newest'
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run from the Apify API with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/vitacost-product-reviews-scraper').call(run_input={
    'productIds': ['10390054928699'],
    'maxReviewsPerProduct': 50,
    'verifiedOnly': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Run with cURL

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

Poll the returned run ID or use an Apify webhook for completion.

### Use with Apify MCP

Connect AI assistants through [Apify MCP](https://mcp.apify.com/?tools=automation-lab/vitacost-product-reviews-scraper).

#### Claude Code setup

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

Example prompt:

> Extract the newest 30 reviews for this Vitacost product and summarize repeated quality complaints with source review UUIDs.

#### Claude Desktop setup

Add the following remote MCP server configuration:

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

Example prompt:

> Compare one-star and five-star themes for product ID 10390054928699 and return a concise evidence table.

#### Cursor setup

Open **Settings → Tools & MCP**, add a remote MCP server, and use the same JSON configuration and URL above.

#### VS Code setup

Open the MCP server settings for your AI extension and add the same `apify` remote server URL shown above.

### Tips for reliable results

- Use canonical Vitacost product-detail URLs.
- Start with 10 reviews before scaling a workflow.
- Use product IDs when your catalog already stores them.
- Keep stable `reviewId` values for incremental monitoring.
- Filter after a broad test if you are unsure whether verified reviews exist.
- Use newest-first order for scheduled jobs.
- Keep the product URL alongside exported rows for traceability.

### Troubleshooting

#### Why did my run return no matching reviews?

Your rating or verified-buyer filters may exclude every available review.

Relax the filters and rerun with a low cap to inspect the current product mix.

#### Why was my URL rejected?

The actor accepts only HTTPS product-detail URLs on `www.vitacost.com`.

Collection pages, search pages, other domains, and malformed URLs are rejected to prevent wrong-scope output.

#### Why is a product URL missing for an ID lookup?

A no-review product may not expose a canonical path in the public review response.

Rows with reviews normally include a public relative product path that the actor converts to an absolute URL.

#### Can I scrape every review?

Yes. Set `maxReviewsPerProduct` above the product's public review count, up to the input maximum.

### Data quality and limitations

The actor extracts publicly visible review data supplied by Vitacost's review widget.

Optional fields may be `null` or empty when a reviewer did not provide them.

Verified-buyer and transparency fields reproduce public labels; they are not independent identity verification.

Review counts and averages reflect the source at extraction time.

Vitacost or its review provider may change public fields without notice.

### Is it legal to scrape Vitacost reviews?

The actor accesses public product-review information without logging in.

Your use must comply with applicable laws, contracts, privacy obligations, and Vitacost's terms.

Avoid collecting more data than needed.

Do not use public reviewer information for harassment, sensitive profiling, or unsolicited contact.

Consult legal counsel for regulated or high-risk use cases.

### FAQ

#### Does it require a Vitacost account?

No. The supported review surface is public.

#### Does it use a browser?

No. It uses lightweight HTTP extraction for lower cost and faster startup.

#### Can it scrape multiple products?

Yes. Supply multiple URLs, IDs, or both.

#### Are duplicate reviews removed?

Yes. Stable review UUIDs are deduplicated across the run.

#### Can I export CSV or Excel?

Yes. Use the dataset export controls or dataset API.

#### Can I filter by date?

Date filtering is not a current input. Use newest-first order and filter `reviewDate` in your downstream workflow.

#### Can I collect product questions?

No. This actor intentionally emits one entity type: product reviews.

### Related scrapers

Combine this actor with other [automation-lab actors](https://apify.com/automation-lab) for broader commerce research.

- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper)
- [Walmart Reviews Scraper](https://apify.com/automation-lab/walmart-reviews-scraper)
- [Chewy Product Reviews Scraper](https://apify.com/automation-lab/chewy-product-reviews-scraper)
- [Costco Product Reviews Scraper](https://apify.com/automation-lab/costco-product-reviews-scraper)

### Support

If a valid Vitacost product stops returning public reviews, open an issue from the actor page.

Include the product URL, input, run ID, expected behavior, and observed result.

These details make source changes faster to reproduce and fix.

# Actor input Schema

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

One or more https://www.vitacost.com/products/... pages. URLs outside the Vitacost product catalog are rejected.

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

Optional Vitacost/Judge.me numeric product IDs, such as 10390054928699.

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

Stops after this many matching reviews for each product.

## `ratings` (type: `array`):

Optional ratings to keep. Leave empty to collect all 1–5 star reviews.

## `verifiedOnly` (type: `boolean`):

When enabled, only reviews marked as verified purchases are saved.

## `sortBy` (type: `string`):

Choose the order used while collecting reviews.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.vitacost.com/products/vitacost-vitamin-d3-mini-gels-125-mcg-5-000-iu-365-softgels-158727"
    }
  ],
  "productIds": [],
  "maxReviewsPerProduct": 10,
  "ratings": [],
  "verifiedOnly": false,
  "sortBy": "newest"
}
```

# Actor output Schema

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

One typed dataset row per public Vitacost product review.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.vitacost.com/products/vitacost-vitamin-d3-mini-gels-125-mcg-5-000-iu-365-softgels-158727"
        }
    ],
    "maxReviewsPerProduct": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/vitacost-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 = {
    "startUrls": [{ "url": "https://www.vitacost.com/products/vitacost-vitamin-d3-mini-gels-125-mcg-5-000-iu-365-softgels-158727" }],
    "maxReviewsPerProduct": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/vitacost-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 '{
  "startUrls": [
    {
      "url": "https://www.vitacost.com/products/vitacost-vitamin-d3-mini-gels-125-mcg-5-000-iu-365-softgels-158727"
    }
  ],
  "maxReviewsPerProduct": 10
}' |
apify call automation-lab/vitacost-product-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vitacost Product Reviews Scraper",
        "description": "💊 Export public Vitacost product reviews, ratings, buyer details, helpfulness, media, replies, and sentiment summaries for supplement research.",
        "version": "0.1",
        "x-build-id": "xa7jlhL8i1tMRex8v"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~vitacost-product-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-vitacost-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~vitacost-product-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-vitacost-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~vitacost-product-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-vitacost-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": {
                    "startUrls": {
                        "title": "🛍️ Vitacost product URLs",
                        "type": "array",
                        "description": "One or more https://www.vitacost.com/products/... pages. URLs outside the Vitacost product catalog are rejected.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "productIds": {
                        "title": "🔢 Product IDs",
                        "type": "array",
                        "description": "Optional Vitacost/Judge.me numeric product IDs, such as 10390054928699.",
                        "default": [],
                        "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.",
                        "default": 100
                    },
                    "ratings": {
                        "title": "Star ratings",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional ratings to keep. Leave empty to collect all 1–5 star reviews.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "verifiedOnly": {
                        "title": "Verified buyers only",
                        "type": "boolean",
                        "description": "When enabled, only reviews marked as verified purchases are saved.",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Review order",
                        "enum": [
                            "newest",
                            "highest_rating",
                            "lowest_rating"
                        ],
                        "type": "string",
                        "description": "Choose the order used while collecting reviews.",
                        "default": "newest"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
