# IKEA Reviews Scraper (`e-commerce/ikea-reviews-scraper`) Actor

Scrape IKEA product reviews: author, rating, date, title, and text. Provide product URLs, a category or listing URL, or a search keyword. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/e-commerce/ikea-reviews-scraper.md
- **Developed by:** [E Commerce](https://apify.com/e-commerce) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.70 / 1,000 review details

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

**Powered by [E-commerce Scraping Tool](https://apify.com/apify/e-commerce-scraping-tool).** Need data from other stores too? The E-commerce Scraping Tool gets you data from IKEA, Amazon, eBay, and any other e-commerce site.

## IKEA Reviews Scraper

Extract IKEA product reviews at scale: reviewer, star rating, date, title, and full text, from any IKEA product URL, category page, or search keyword. Built for sentiment analysis, product-quality research, and voice-of-customer content.

IKEA shoppers leave detailed reviews about assembly, sizing, sturdiness, and value on ranges like BILLY, KALLAX, and POÄNG, across 50+ country sites. This Actor turns those reviews into clean, structured data you can analyze at scale.

### What does IKEA Reviews Scraper do?

IKEA Reviews Scraper collects customer reviews from IKEA.com and returns them as JSON, CSV, or Excel. Give it product URLs, a category (listing) URL, or a search keyword, and it returns every review it can find for each matching product.

- ⭐ Scrape all reviews for any IKEA product by URL
- 📂 Collect reviews across a whole category or search results page
- 🔎 Search IKEA by keyword and scrape reviews for the matching products
- 🌍 Works across 20+ IKEA country sites (US, UK, DE, FR, CA, and more)
- 📦 Export to JSON, CSV, Excel, XML, or HTML, or pull results via API

### What review data can you extract from IKEA?

The IKEA Reviews Scraper returns the following fields for each review:

| Review data       | Rating                         | Context        |
| ----------------- | ------------------------------ | -------------- |
| 👤 Author         | ⭐ Rating value                | 🔗 Product URL |
| 🗓️ Date published | 🔝 Best / worst rating         | 🏷️ Input URL   |
| 📝 Title          | 📊 Extra attributes (optional) | 🔎 Keyword     |
| 💬 Review text    |                                |                |

Enable **Include additional properties** to capture extra review attributes (such as verified-purchase flags or secondary ratings) under `additionalProperties`.

### Can I scrape IKEA reviews by product, category, or keyword?

Yes. IKEA Reviews Scraper accepts three kinds of input and resolves all of them to products, then scrapes each product's reviews:

- **Product URLs**: direct links to IKEA product (`/p/`) pages.
- **Category / listing URLs**: any IKEA `/cat/` or search-results page. The Actor collects the products found and scrapes their reviews.
- **Search keyword**: a search term run against the IKEA country site you choose.

It supports IKEA sites including the United States, United Kingdom, Canada, Australia, Germany, France, Spain, Italy, the Netherlands, Sweden, Poland, Japan, and more.

### How does IKEA Reviews Scraper work?

1. You provide product URLs, listing URLs, or a keyword.
2. The Actor expands listing URLs and keyword searches into individual product URLs.
3. For each product, it pages through all available reviews.
4. Each review is saved to your dataset as it completes, so first results appear within a minute.
5. Anything that cannot be scraped is written to a separate errors dataset with a clear reason.

### Why use IKEA Reviews Scraper?

| Feature          | Manual / generic tools    | IKEA Reviews Scraper           |
| ---------------- | ------------------------- | ------------------------------ |
| Setup            | Custom code and selectors | Just paste a URL or keyword    |
| Input types      | One product at a time     | Product, category, and keyword |
| Country coverage | Single site               | 20+ IKEA country sites         |
| Output           | Unstructured HTML         | Clean JSON, CSV, Excel         |
| Pagination       | Manual                    | Automatic across all pages     |
| Cost model       | Fixed subscriptions       | Pay only per review returned   |

### What can you do with IKEA review data?

- **Sentiment analysis**: measure how customers feel about a range and track it over time and across countries.
- **Product-quality research**: surface recurring complaints about assembly, sizing, or durability for a specific product.
- **Voice-of-customer content**: pull real quotes and ratings for product pages, FAQs, and marketing.
- **Cross-market comparison**: compare review volume and average ratings for the same article number between IKEA country sites.

### How to use IKEA Reviews Scraper?

1. Create a free Apify account.
2. Open the IKEA Reviews Scraper.
3. Paste IKEA product URLs, a category URL, or type a keyword and pick the IKEA country site.
4. Set **Total maximum reviews** to cap the run (start with 100 to preview).
5. Click **Start**, then export your results or fetch them from the API.

### How much does IKEA Reviews Scraper cost?

It uses a **pay-per-event** model: a tiny fee per run start, plus a fee per review returned, $0.002 per review on the Free plan, dropping to $0.0004 per review on higher plans. You are never charged for failed pages, and runs stay predictable because you control the review cap. See the Pricing tab for current rates.

### Input

Provide at least one of: product URLs, listing URLs, or a keyword.

| Field                  | Type    | Description                                    |
| ---------------------- | ------- | ---------------------------------------------- |
| `detailsUrls`          | array   | IKEA product (`/p/`) URLs whose reviews to get |
| `listingUrls`          | array   | IKEA category or search-results URLs           |
| `keyword`              | string  | Search term for the selected IKEA country site |
| `country`              | string  | IKEA country site used for keyword search      |
| `additionalProperties` | boolean | Include extra, source-specific review fields   |
| `maxReviewResults`     | integer | Total reviews to scrape across the run         |

Example input:

```json
{
  "detailsUrls": [{ "url": "https://www.ikea.com/us/en/p/billy-bookcase-white-00263850/" }],
  "keyword": "billy bookcase",
  "country": "www.ikea.com/us/en",
  "additionalProperties": true,
  "maxReviewResults": 100
}
````

### Output

Each review is saved as one dataset item. Failed inputs go to a separate errors dataset.

```json
{
  "productUrl": "https://www.ikea.com/us/en/p/billy-bookcase-white-00263850/",
  "author": "María Pilar",
  "datePublished": "2026-06-25",
  "name": "Very practical",
  "reviewBody": "Exactly what I expected, functional and pretty.",
  "reviewRating": { "ratingValue": 5, "bestRating": 5, "worstRating": 1 },
  "inputUrl": "https://www.ikea.com/us/en/p/billy-bookcase-white-00263850/"
}
```

### How to run IKEA Reviews Scraper via the API

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~ikea-reviews-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "detailsUrls": [{ "url": "https://www.ikea.com/us/en/p/billy-bookcase-white-00263850/" }], "maxReviewResults": 50 }'
```

### Troubleshooting

- **A run returns 0 reviews.** The product may simply have no reviews yet, or IKEA blocked the request. The Actor records blocked products in the errors dataset with the reason, so a zero-result run is never silent; re-run in a few minutes if you see "blocked".
- **"Not a valid IKEA product URL".** Product input must be an `ikea.com` product page (its path contains `/p/`). Put category or search pages in **Category / listing URLs** instead.
- **Keyword search returns no products.** Set **IKEA country site** to the market your keyword belongs to.
- **Fewer reviews than expected.** Raise **Total maximum reviews**; the cap applies to the whole run across all products.

### Are there other tools in Apify Store?

- 🛋️ **IKEA Product Scraper**: extract IKEA product data (name, price, brand, images, description).
- 🛍️ **E-commerce Scraping Tool**: get product, review, and seller data from many marketplaces.
- 🟦 **eBay Scraper**: extract eBay product, listing, and review data.

### FAQ

**Can I collect reviews for a whole IKEA category?**
Yes. Pass a category URL and the Actor finds every product on it, then scrapes each product's reviews.

**Can I compare IKEA ratings between countries?**
Yes. Scrape reviews for the same product on different IKEA country sites and compare the ratings and volume.

**How many reviews can I scrape per run?**
As many as you want. Use `maxReviewResults` to cap the total across all products.

**Are reviews in the local language?**
Yes. Reviews come in the language of the IKEA country site, so a German site returns German reviews.

**Can I scrape reviews behind login?**
No. The Actor only collects publicly visible reviews.

**Can I schedule review monitoring?**
Yes. Schedule recurring runs and store each dataset to track sentiment over time.

**Can I use it with the Apify API or an MCP Server?**
Yes. Start runs and fetch results through the Apify API, and call the Actor from AI agents through the Apify MCP Server.

**Is scraping IKEA reviews legal?**
Scraping publicly available data is generally legal. This Actor collects only public review content and no personal data beyond the public reviewer name. Always follow applicable laws and IKEA's terms.

### Your feedback

Found a bug or want a new field? Open an issue on the Actor's Issues tab. We read every report.

# Actor input Schema

## `detailsUrls` (type: `array`):

Direct URLs to IKEA product pages whose reviews you want. The IKEA Reviews Scraper fetches every review for each product: author, rating, date, and text. Example: https://www.ikea.com/us/en/p/billy-bookcase-white-00263850/. Accepts IKEA product (/p/) URLs, with or without https://; put category or search URLs in the fields below instead. Use this when you already know exactly which products' reviews you want.

## `listingUrls` (type: `array`):

URLs to IKEA category or listing pages. The scraper collects the product URLs on each listing (following pagination), then scrapes the reviews of every product found. Example: https://www.ikea.com/us/en/cat/bookcases-10382/. Accepts IKEA category (/cat/) or search-result URLs. Use this to collect reviews across a whole category; pair it with 'Total maximum reviews' to cap the run.

## `keyword` (type: `string`):

A search term used to find IKEA products whose reviews will be scraped. The scraper runs the search on the selected IKEA country site, collects the matching product URLs, then scrapes each product's reviews. Example: billy bookcase. Enter a single search phrase, and pair it with the 'IKEA country site' option below.

## `country` (type: `string`):

The IKEA country and language site used for keyword search. The scraper sends your keyword to this IKEA store to find products, then scrapes their reviews. Example: IKEA (United States – English). This only affects keyword search — product and category URLs already contain their own country. Default is the United States (English).

## `additionalProperties` (type: `boolean`):

Whether to include extra, source-specific review attributes in the output. When enabled, the scraper asks IKEA for additional review details and adds them under 'additionalProperties'. Example: enable this to capture verified-purchase flags or secondary ratings when available. This adds more data per review at a small extra time cost. Recommended: on for richer analysis, off for the fastest rating-and-text-only runs.

## `maxReviewResults` (type: `integer`):

The maximum total number of reviews to scrape in one run, across all products. The scraper stops once this many reviews have been saved, so popular products never run away. Example: 200. Accepts any positive whole number. Lower values cost less and finish faster; leave empty to scrape every review found. Recommended: start with 100–200 to preview results before a full run.

## Actor input object example

```json
{
  "detailsUrls": [
    {
      "url": "https://www.ikea.com/us/en/p/billy-bookcase-white-00263850/"
    }
  ],
  "listingUrls": [
    {
      "url": "https://www.ikea.com/us/en/cat/bookcases-10382/"
    }
  ],
  "keyword": "billy bookcase",
  "country": "www.ikea.com/us/en",
  "additionalProperties": true,
  "maxReviewResults": 100
}
```

# Actor output Schema

## `results` (type: `string`):

Scraped IKEA product reviews.

## `errors` (type: `string`):

Products or keywords that could not be scraped, with an error code and 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 = {
    "detailsUrls": [
        {
            "url": "https://www.ikea.com/us/en/p/billy-bookcase-white-00263850/"
        }
    ],
    "country": "www.ikea.com/us/en",
    "additionalProperties": true,
    "maxReviewResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("e-commerce/ikea-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 = {
    "detailsUrls": [{ "url": "https://www.ikea.com/us/en/p/billy-bookcase-white-00263850/" }],
    "country": "www.ikea.com/us/en",
    "additionalProperties": True,
    "maxReviewResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("e-commerce/ikea-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 '{
  "detailsUrls": [
    {
      "url": "https://www.ikea.com/us/en/p/billy-bookcase-white-00263850/"
    }
  ],
  "country": "www.ikea.com/us/en",
  "additionalProperties": true,
  "maxReviewResults": 100
}' |
apify call e-commerce/ikea-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "IKEA Reviews Scraper",
        "description": "Scrape IKEA product reviews: author, rating, date, title, and text. Provide product URLs, a category or listing URL, or a search keyword. Export data, run via API, schedule and monitor runs, or integrate with other tools.",
        "version": "0.0",
        "x-build-id": "SZRQY4L0CrfIqMLr9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/e-commerce~ikea-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-e-commerce-ikea-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/e-commerce~ikea-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-e-commerce-ikea-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/e-commerce~ikea-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-e-commerce-ikea-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": {
                    "detailsUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Direct URLs to IKEA product pages whose reviews you want. The IKEA Reviews Scraper fetches every review for each product: author, rating, date, and text. Example: https://www.ikea.com/us/en/p/billy-bookcase-white-00263850/. Accepts IKEA product (/p/) URLs, with or without https://; put category or search URLs in the fields below instead. Use this when you already know exactly which products' reviews you want.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "listingUrls": {
                        "title": "Category / listing URLs",
                        "type": "array",
                        "description": "URLs to IKEA category or listing pages. The scraper collects the product URLs on each listing (following pagination), then scrapes the reviews of every product found. Example: https://www.ikea.com/us/en/cat/bookcases-10382/. Accepts IKEA category (/cat/) or search-result URLs. Use this to collect reviews across a whole category; pair it with 'Total maximum reviews' to cap the run.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "keyword": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "A search term used to find IKEA products whose reviews will be scraped. The scraper runs the search on the selected IKEA country site, collects the matching product URLs, then scrapes each product's reviews. Example: billy bookcase. Enter a single search phrase, and pair it with the 'IKEA country site' option below."
                    },
                    "country": {
                        "title": "IKEA country site (for keyword search)",
                        "enum": [
                            "www.ikea.com/us/en",
                            "www.ikea.com/gb/en",
                            "www.ikea.com/ca/en",
                            "www.ikea.com/au/en",
                            "www.ikea.com/ie/en",
                            "www.ikea.com/de/de",
                            "www.ikea.com/fr/fr",
                            "www.ikea.com/es/es",
                            "www.ikea.com/it/it",
                            "www.ikea.com/nl/nl",
                            "www.ikea.com/be/en",
                            "www.ikea.com/ch/en",
                            "www.ikea.com/at/de",
                            "www.ikea.com/se/en",
                            "www.ikea.com/no/no",
                            "www.ikea.com/dk/da",
                            "www.ikea.com/fi/en",
                            "www.ikea.com/pt/pt",
                            "www.ikea.com/pl/pl",
                            "www.ikea.com/cz/cs",
                            "www.ikea.com/jp/en",
                            "www.ikea.com/kr/en",
                            "www.ikea.com/in/en",
                            "www.ikea.com/mx/es"
                        ],
                        "type": "string",
                        "description": "The IKEA country and language site used for keyword search. The scraper sends your keyword to this IKEA store to find products, then scrapes their reviews. Example: IKEA (United States – English). This only affects keyword search — product and category URLs already contain their own country. Default is the United States (English).",
                        "default": "www.ikea.com/us/en"
                    },
                    "additionalProperties": {
                        "title": "Include additional properties",
                        "type": "boolean",
                        "description": "Whether to include extra, source-specific review attributes in the output. When enabled, the scraper asks IKEA for additional review details and adds them under 'additionalProperties'. Example: enable this to capture verified-purchase flags or secondary ratings when available. This adds more data per review at a small extra time cost. Recommended: on for richer analysis, off for the fastest rating-and-text-only runs.",
                        "default": false
                    },
                    "maxReviewResults": {
                        "title": "Total maximum reviews",
                        "minimum": 1,
                        "type": "integer",
                        "description": "The maximum total number of reviews to scrape in one run, across all products. The scraper stops once this many reviews have been saved, so popular products never run away. Example: 200. Accepts any positive whole number. Lower values cost less and finish faster; leave empty to scrape every review found. Recommended: start with 100–200 to preview results before a full run."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
