# IKEA Product Reviews Scraper (`automation-lab/ikea-product-reviews-scraper`) Actor

🛋️ Turn public IKEA US product reviews into structured data with ratings, text, reviewer details, verification, helpful votes, media, responses, and aggregate stats.

- **URL**: https://apify.com/automation-lab/ikea-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

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

## IKEA Product Reviews Scraper

Extract public IKEA customer reviews into clean JSON, CSV, Excel, or API-ready datasets.

Give the Actor one or more IKEA US product URLs. It returns one row per review with the rating, title, full text, reviewer, date, verification, helpful votes, media links, IKEA response, and product-level rating context.

Use it for recurring product quality tracking, reputation monitoring, competitive research, and customer sentiment analysis without manually copying review cards.

### What does IKEA Product Reviews Scraper do?

IKEA Product Reviews Scraper collects public buyer feedback from `ikea.com/us/en` product pages.

It can:

- 🛋️ process several IKEA product URLs in one run;
- ⭐ extract individual ratings, titles, and complete review text;
- 👤 capture public reviewer and locale details;
- ✅ identify verified purchases and verified reviewers;
- 👍 collect helpful and unhelpful vote counts;
- 🖼️ preserve public review media URLs;
- 💬 include public IKEA responses to reviews;
- 📊 attach aggregate rating and total review count to every row;
- 🔁 order reviews by recency, rating, or helpfulness;
- 📦 export results through Apify datasets and integrations.

The current version supports the proven IKEA US English product surface.

### Who is it for?

#### Product and reputation teams

Track complaints, praise, assembly problems, durability concerns, and changing customer expectations across a catalog.

#### Furniture brands and sellers

Compare recurring feedback about competing IKEA products with reviews of your own assortment.

#### Market researchers

Build structured evidence for category reports instead of sampling reviews by hand.

#### Data and BI teams

Schedule a repeatable review feed into dashboards, warehouses, or sentiment pipelines.

#### Agencies and consultants

Deliver product-level voice-of-customer datasets to retail and consumer-goods clients.

### Why use this IKEA review extractor?

Public IKEA pages are designed for shoppers, not bulk analysis. Review cards must otherwise be opened, copied, normalized, and joined with product context manually.

This Actor provides:

- stable review IDs for deduplication;
- typed numeric and boolean fields;
- consistent article IDs and source URLs;
- one review per dataset row;
- configurable limits for cheap tests or deeper monitoring;
- direct public-data extraction without a login;
- automatic retries and clear input validation.

The Actor uses IKEA's public review data surface rather than rendering a full browser page, which keeps runs fast and efficient.

### What IKEA review data can I extract?

| Field | Description |
|---|---|
| `reviewId` | Stable public review identifier |
| `productId` | Article ID from the requested URL |
| `sourceProductId` | Source variant/article attached to a family review |
| `productName` | IKEA product family name |
| `productUrl` | Canonical requested product URL |
| `rating` | Numeric review score |
| `ratingRange` | Maximum rating, normally 5 |
| `title` | Review headline |
| `reviewText` | Full public review text |
| `reviewerName` | Public display name when available |
| `reviewerCountryCode` | Review source country |
| `reviewerLanguageCode` | Review source language |
| `submissionDate` | Public submission timestamp |
| `verifiedPurchase` | Whether IKEA marks the purchase as verified |
| `helpfulVotes` | Positive feedback votes |
| `unhelpfulVotes` | Negative feedback votes |
| `mediaUrls` | Public image/media links |
| `responseText` | Public IKEA response when present |
| `averageRating` | Product aggregate rating |
| `totalReviewCount` | Product aggregate review count |
| `scrapedAt` | Extraction timestamp |

Optional fields are omitted when IKEA does not expose them.

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

The Actor uses pay-per-event pricing:

- a small **$0.005 start fee** per run;
- a per-review event with plan-based volume discounts;
- the current BRONZE price is **$0.000046786 per saved review**.

At that price, a run returning 100 reviews costs about $0.00968, including the start fee, before platform allowances.

Keep `maxReviews` low for your first run. The input prefill requests only five reviews.

Final live prices are always shown in the Apify Console before a run starts.

### How to scrape IKEA reviews in 4 steps

1. Open the Actor input page.
2. Paste one or more IKEA US English product URLs.
3. Choose a review limit and sort order.
4. Click **Start** and open the default dataset.

You can download the result as JSON, CSV, Excel, XML, or RSS, or consume it through the Apify API.

### Input parameters

#### `productUrls`

Required list of public IKEA product pages.

Supported format:

```text
https://www.ikea.com/us/en/p/billy-bookcase-black-oak-effect-40477340/
````

URLs outside `/us/en/p/`, non-IKEA domains, and URLs without an eight-digit article number fail closed.

#### `maxReviews`

Maximum reviews saved **per product URL**.

- minimum: 1
- maximum: 500
- default: 20
- prefill: 5

#### `sort`

Choose one:

- `newest`
- `highest-rated`
- `lowest-rated`
- `most-helpful`

#### `proxyConfiguration`

Direct extraction normally works. Advanced users can enable Apify Proxy or supply custom proxy URLs if their network encounters regional blocking.

### Example input

```json
{
  "productUrls": [
    "https://www.ikea.com/us/en/p/billy-bookcase-black-oak-effect-40477340/"
  ],
  "maxReviews": 20,
  "sort": "newest",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

To compare several products, add more URLs. The limit applies independently to each product.

### Example output

```json
{
  "reviewId": "13f5859c-1a86-49dc-b6b8-5297e42407be",
  "productId": "40477340",
  "sourceProductId": "40477340",
  "productName": "BILLY",
  "productUrl": "https://www.ikea.com/us/en/p/billy-bookcase-black-oak-effect-40477340/",
  "rating": 5,
  "ratingRange": 5,
  "title": "Quick assembly and install",
  "reviewText": "Quality is very good...",
  "reviewerName": "Iva",
  "reviewerCountryCode": "us",
  "reviewerLanguageCode": "en",
  "verifiedPurchase": true,
  "verifiedReviewer": false,
  "helpfulVotes": 0,
  "unhelpfulVotes": 0,
  "hasMedia": false,
  "mediaUrls": [],
  "averageRating": 4.6,
  "totalReviewCount": 3079,
  "locale": "en-US",
  "scrapedAt": "2026-07-21T00:00:00.000Z"
}
```

Values change as customers add or update reviews.

### Review sorting strategies

Use `newest` for monitoring and incremental collection.

Use `most-helpful` to identify feedback shoppers found useful.

Use `lowest-rated` to prioritize product defects, missing parts, delivery damage, or assembly problems.

Use `highest-rated` to identify features customers value and language that supports merchandising research.

Stable review IDs let downstream systems remove records already seen in an earlier run.

### Tips for reliable IKEA review monitoring

- Start with 5-20 reviews while validating your workflow.
- Schedule `newest` runs and deduplicate on `reviewId`.
- Keep the original `productUrl` as your catalog join key.
- Use `sourceProductId` to detect reviews syndicated across product variants.
- Treat reviewer names as public display labels, not verified identities.
- Expect aggregate counts to change independently of the selected review limit.
- Check Actor logs if a product was removed or no longer exposes reviews.

### Integrations and automation workflows

#### Google Sheets and Airtable

Send each new review to a table, then filter by rating or verified purchase.

#### Slack and email alerts

Trigger an alert when a scheduled run finds a one-star review or a product response.

#### BigQuery, Snowflake, and PostgreSQL

Load stable review rows into a warehouse for trend analysis across article IDs.

#### Sentiment and topic analysis

Pass `reviewText` to an NLP service or LLM and aggregate themes by product, month, or rating.

#### Zapier and Make

Use an Apify run-completed trigger to connect the dataset to no-code business workflows.

#### Webhooks

Configure a webhook to process the dataset immediately after each successful run.

### Use the Actor with the Apify API

Replace `<APIFY_TOKEN>` with your token.

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ikea-product-reviews-scraper').call({
  productUrls: ['https://www.ikea.com/us/en/p/billy-bookcase-black-oak-effect-40477340/'],
  maxReviews: 20,
  sort: 'newest'
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("automation-lab/ikea-product-reviews-scraper").call(run_input={
    "productUrls": ["https://www.ikea.com/us/en/p/billy-bookcase-black-oak-effect-40477340/"],
    "maxReviews": 20,
    "sort": "newest",
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~ikea-product-reviews-scraper/runs?token=<APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"productUrls":["https://www.ikea.com/us/en/p/billy-bookcase-black-oak-effect-40477340/"],"maxReviews":20,"sort":"newest"}'
```

### Use IKEA Product Reviews Scraper with MCP

Connect the Actor to AI clients through Apify MCP.

#### Claude Code

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

#### Claude Desktop, Cursor, or VS Code

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

Example prompts:

- “Extract the 20 newest reviews from this IKEA product URL.”
- “Find the most helpful complaints about these IKEA bookcases.”
- “Compare recurring quality themes across these three IKEA products.”

### Data quality and deduplication

The Actor maps IKEA's public structured review records rather than inferring data from visible card positions.

Each saved row requires a stable review ID and numeric rating.

Duplicate IDs are removed within a run, including duplicates returned through IKEA product-family relationships.

Numbers remain numbers, booleans remain booleans, and optional unavailable values are omitted rather than replaced with misleading placeholders.

### Limitations

- V1 supports IKEA US English product pages only.
- Search pages, category pages, carts, and non-product URLs are rejected.
- The Actor extracts public reviews; it does not submit, edit, or vote on them.
- A source product may have fewer reviews than your requested limit.
- IKEA can change its public website or data endpoints.
- Product-family reviews can reference a different `sourceProductId` from the requested article.
- Public reviewer fields vary by review and may be absent.

### Is it legal to scrape IKEA product reviews?

This Actor extracts information publicly available without a login.

You are responsible for your use of the data. Follow applicable laws, IKEA's terms, database rights, copyright rules, and privacy obligations.

Avoid using reviewer display names for identification or unsolicited contact. Store only the fields necessary for your legitimate purpose and apply appropriate retention controls.

This page is general information, not legal advice.

### Troubleshooting

#### Why did my URL fail validation?

Confirm that it is an IKEA US English product URL beginning with `https://www.ikea.com/us/en/p/` and ending in an eight-digit article number.

#### Why did the run return fewer reviews than requested?

The product may expose fewer public reviews, or IKEA may deduplicate/syndicate reviews across product variants. Check `totalReviewCount` for aggregate context.

#### Why did the run fail with no reviews extracted?

Open the product page manually and confirm that it still exists and has public customer reviews. Then inspect the Actor log. If your network is regionally blocked, enable Apify Proxy in advanced input.

#### Why is `sourceProductId` different?

IKEA can associate reviews with related variants in a product family. `productId` always identifies your requested URL; `sourceProductId` records the review's originating article.

### Frequently asked questions

#### Does it require an IKEA account?

No. It accesses public review data without login credentials.

#### Can I scrape several products?

Yes. Add multiple URLs to `productUrls`; `maxReviews` applies to each URL.

#### Can I schedule it?

Yes. Create an Apify schedule and use `newest` ordering for repeat monitoring.

#### Are media files downloaded?

No. The dataset contains public media URLs so your workflow can decide whether to fetch them.

#### Does it perform sentiment analysis?

It returns clean review text suitable for sentiment analysis. Connect the dataset to your preferred NLP model or LLM.

### Related product review scrapers

- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper)
- [Walmart Reviews Scraper](https://apify.com/automation-lab/walmart-reviews-scraper)
- [Home Depot Product Reviews Scraper](https://apify.com/automation-lab/home-depot-product-reviews-scraper)
- [Lowe's Product Reviews Scraper](https://apify.com/automation-lab/lowes-product-reviews-scraper)
- [Costco Product Reviews Scraper](https://apify.com/automation-lab/costco-product-reviews-scraper)

Choose this Actor when IKEA US customer feedback is your primary source and you need one normalized row per review.

### Support

If a valid IKEA US product page stops working, open an issue from the Actor page.

Include:

- the product URL;
- the run ID;
- the expected review count or field;
- whether proxy configuration was enabled.

Do not include passwords, private customer data, or API tokens.

# Actor input Schema

## `productUrls` (type: `array`):

Enter IKEA US English product URLs in the /us/en/p/ format.

## `maxReviews` (type: `integer`):

Stop after this many reviews for each product URL.

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

Choose how IKEA reviews are ordered before extraction.

## `proxyConfiguration` (type: `object`):

Optionally route IKEA API requests through Apify Proxy or your own proxy URLs.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.ikea.com/us/en/p/billy-bookcase-black-oak-effect-40477340/"
  ],
  "maxReviews": 5,
  "sort": "newest",
  "proxyConfiguration": {
    "useApifyProxy": 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 = {
    "productUrls": [
        "https://www.ikea.com/us/en/p/billy-bookcase-black-oak-effect-40477340/"
    ],
    "maxReviews": 5,
    "sort": "newest",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ikea-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 = {
    "productUrls": ["https://www.ikea.com/us/en/p/billy-bookcase-black-oak-effect-40477340/"],
    "maxReviews": 5,
    "sort": "newest",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ikea-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 '{
  "productUrls": [
    "https://www.ikea.com/us/en/p/billy-bookcase-black-oak-effect-40477340/"
  ],
  "maxReviews": 5,
  "sort": "newest",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/ikea-product-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "IKEA Product Reviews Scraper",
        "description": "🛋️ Turn public IKEA US product reviews into structured data with ratings, text, reviewer details, verification, helpful votes, media, responses, and aggregate stats.",
        "version": "0.1",
        "x-build-id": "10hDMPgufCnF6YrMc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ikea-product-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ikea-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~ikea-product-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ikea-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~ikea-product-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ikea-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": [
                    "productUrls"
                ],
                "properties": {
                    "productUrls": {
                        "title": "IKEA product URLs",
                        "type": "array",
                        "description": "Enter IKEA US English product URLs in the /us/en/p/ format.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Maximum reviews per product",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Stop after this many reviews for each product URL.",
                        "default": 20
                    },
                    "sort": {
                        "title": "Review order",
                        "enum": [
                            "newest",
                            "highest-rated",
                            "lowest-rated",
                            "most-helpful"
                        ],
                        "type": "string",
                        "description": "Choose how IKEA reviews are ordered before extraction.",
                        "default": "newest"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optionally route IKEA API requests through Apify Proxy or your own proxy URLs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
