# IKEA Product Scraper (`e-commerce/ikea-product-scraper`) Actor

Scrape IKEA product data: name, price, currency, brand, image, and description. 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-product-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**: No ratings yet

## Pricing

from $1.00 / 1,000 product 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 Product Scraper

Extract IKEA product data at scale: name, price, currency, brand, images, and description, from any IKEA product URL, category page, or search keyword. Built for price monitoring across IKEA's country sites, competitor research, and catalog enrichment.

IKEA lists the same flat-pack ranges (BILLY, KALLAX, POÄNG, MALM, and more) at different prices and availability across 50+ country sites. This Actor turns any IKEA product, category, or search into clean, structured data you can compare and track.

### What does IKEA Product Scraper do?

IKEA Product Scraper collects structured product data from IKEA.com and returns it as JSON, CSV, or Excel. Give it product URLs, a category (listing) URL, or a search keyword, and it returns full product details for every item it finds.

- 🛒 Scrape any IKEA product page by URL
- 📂 Expand a category or search results page into every product it contains
- 🔎 Search IKEA by keyword and scrape 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 data can you extract from IKEA?

The IKEA Product Scraper returns the following fields for each product:

| Product data    | Commercial info | Additional details               |
| --------------- | --------------- | -------------------------------- |
| 📝 Product name | 💰 Price        | 🖼️ Image URL                     |
| 🔗 Product URL  | 💱 Currency     | 📐 Dimensions (optional)         |
| 🏢 Brand        | 🏷️ Input URL    | 🧵 Materials and care (optional) |
| 📄 Description  | 🔎 Keyword      | 📊 Extra attributes (optional)   |

Enable **Include additional properties** to capture dimensions, materials, care instructions, and other IKEA-specific attributes under `additionalProperties`.

### Can I scrape IKEA products, categories, and search results?

Yes. IKEA Product Scraper accepts three kinds of input and resolves all of them to product pages:

- **Product URLs**: direct links to IKEA product (`/p/`) pages.
- **Category / listing URLs**: any IKEA `/cat/` or search-results page. The Actor collects the product links it finds and follows pagination.
- **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 Product 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. It requests each product page and extracts the structured data.
4. Each product 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 Product Scraper?

| Feature          | Manual / generic tools    | IKEA Product Scraper           |
| ---------------- | ------------------------- | ------------------------------ |
| Setup            | Custom code and selectors | Just paste a URL or keyword    |
| Input types      | One URL at a time         | Product, category, and keyword |
| Country coverage | Single site               | 20+ IKEA country sites         |
| Output           | Unstructured HTML         | Clean JSON, CSV, Excel         |
| Failures         | Silent, break the run     | Logged to an errors dataset    |
| Cost model       | Fixed subscriptions       | Pay only per product returned  |

### What can you do with IKEA data after scraping?

- **Cross-country price monitoring**: track the price of the same article number across IKEA's US, UK, and EU sites to spot the cheapest market.
- **Catalog enrichment**: pull names, images, dimensions, and materials to populate a furniture catalog or an interior-design or AI shopping tool.
- **Range and availability research**: follow when ranges like BILLY or KALLAX change price or get new variants.
- **Competitor benchmarking**: compare IKEA pricing against other furniture retailers.

### How to use IKEA Product Scraper?

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

### How much does IKEA Product Scraper cost?

It uses a **pay-per-event** model: a tiny fee per run start, plus a fee per product returned, $0.006 per product on the Free plan, dropping to $0.0005 per product on higher plans. You are never charged for failed pages, and category or keyword runs stay predictable because you control the product cap. The $5 in free monthly Apify credits covers roughly 800 products on the Free plan. 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   | Direct IKEA product (`/p/`) URLs                |
| `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 dimensions, materials, extra attributes |
| `maxProductResults`    | integer | Total products to scrape across the run         |

Example input:

```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,
  "maxProductResults": 50
}
````

### Output

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

```json
{
  "url": "https://www.ikea.com/us/en/p/billy-bookcase-white-00263850/",
  "name": "BILLY Bookcase, white",
  "offers": { "price": 69.99, "currency": "USD" },
  "brand": { "slogan": "IKEA" },
  "description": "Adaptable and much-loved, BILLY bookcase adjusts to your needs.",
  "image": "https://www.ikea.com/us/en/images/products/billy-bookcase-white.jpg",
  "inputUrl": "https://www.ikea.com/us/en/p/billy-bookcase-white-00263850/"
}
```

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

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~ikea-product-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/" }], "maxProductResults": 10 }'
```

### Troubleshooting

- **A run returns 0 products.** IKEA occasionally blocks automated requests to product pages. Re-run in a few minutes; the Actor records each blocked URL in the errors dataset with the reason, so a zero-result run is never silent.
- **"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 nothing.** Set **IKEA country site** to the market your keyword belongs to; a term may exist on one IKEA site but not another.
- **Fewer results than expected.** Raise **Total maximum products**, or check the errors dataset for pages that were blocked or not found.

### Are there other tools in Apify Store?

- ⭐ **IKEA Reviews Scraper**: extract IKEA product reviews (author, rating, date, text).
- 🛍️ **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 get IKEA product dimensions and materials?**
Yes. Enable **Include additional properties** and the Actor adds dimensions, materials, and care information under `additionalProperties`.

**Can I compare IKEA prices between countries?**
Yes. Scrape the same product on different IKEA country sites (each has its own URL) and compare the `offers.price` and `currency` fields.

**Does it work for every IKEA country site?**
It covers 20+ country sites for keyword search, and any IKEA product or category URL regardless of country.

**How many products can I scrape per run?**
As many as you want. Use `maxProductResults` to cap the total across all URLs and keywords.

**Can I scrape IKEA data behind login?**
No. The Actor only collects publicly visible product data.

**Can I schedule IKEA price checks?**
Yes. Schedule recurring runs (hourly, daily, or weekly) and store each dataset to build price history.

**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 data legal?**
Scraping publicly available data is generally legal. This Actor collects only public product information, no personal data. 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 individual IKEA product pages. The IKEA Product Scraper fetches each URL and returns that product's full data — name, price, brand, images, and description. 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 you want — it is the fastest and most reliable input.

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

URLs to IKEA category or listing pages that contain many products. The scraper opens each listing, collects the product URLs it finds (following pagination), then scrapes each product's details. Example: https://www.ikea.com/us/en/cat/bookcases-10382/. Accepts IKEA category (/cat/) or search-result URLs. Use this to scrape a whole category without listing every product URL yourself; pair it with 'Total maximum products' to cap the run.

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

A search term used to find IKEA products. The scraper runs the search on the IKEA site for the selected country, collects the matching product URLs, then scrapes each product's details. Example: billy bookcase. Enter a single search phrase. Pair it with the 'IKEA country site' option below so the search runs on the right store, and use 'Total maximum products' to limit how many results are scraped.

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

The IKEA country and language site used for keyword search. The scraper sends your keyword to this IKEA store and localizes currency, pricing, and availability accordingly. 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); pick the market that matches your keyword and target audience.

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

Whether to include extra, source-specific product attributes in the output. When enabled, the scraper asks IKEA for additional details (such as dimensions, materials, and packaging) and adds them under 'additionalProperties'. Example: enable this to capture material and care information for furniture. This adds more data per product at a small extra time cost. Recommended: on for catalog enrichment, off for the fastest price-and-name-only runs.

## `maxProductResults` (type: `integer`):

The maximum total number of products to scrape in one run, across all URLs and keywords combined. The scraper stops once this many products have been saved, so category and keyword inputs never run away. Example: 100. Accepts any positive whole number. Lower values cost less and finish faster; leave empty to scrape everything found. Recommended: start with 50–100 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,
  "maxProductResults": 50
}
```

# Actor output Schema

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

Scraped IKEA product details.

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

URLs 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,
    "maxProductResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("e-commerce/ikea-product-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,
    "maxProductResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("e-commerce/ikea-product-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,
  "maxProductResults": 50
}' |
apify call e-commerce/ikea-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "IKEA Product Scraper",
        "description": "Scrape IKEA product data: name, price, currency, brand, image, and description. 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": "PkkjRtiYKwlXSiWEv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/e-commerce~ikea-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-e-commerce-ikea-product-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-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-e-commerce-ikea-product-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-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-e-commerce-ikea-product-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 detail URLs",
                        "type": "array",
                        "description": "Direct URLs to individual IKEA product pages. The IKEA Product Scraper fetches each URL and returns that product's full data — name, price, brand, images, and description. 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 you want — it is the fastest and most reliable input.",
                        "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 that contain many products. The scraper opens each listing, collects the product URLs it finds (following pagination), then scrapes each product's details. Example: https://www.ikea.com/us/en/cat/bookcases-10382/. Accepts IKEA category (/cat/) or search-result URLs. Use this to scrape a whole category without listing every product URL yourself; pair it with 'Total maximum products' 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. The scraper runs the search on the IKEA site for the selected country, collects the matching product URLs, then scrapes each product's details. Example: billy bookcase. Enter a single search phrase. Pair it with the 'IKEA country site' option below so the search runs on the right store, and use 'Total maximum products' to limit how many results are scraped."
                    },
                    "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 and localizes currency, pricing, and availability accordingly. 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); pick the market that matches your keyword and target audience.",
                        "default": "www.ikea.com/us/en"
                    },
                    "additionalProperties": {
                        "title": "Include additional properties",
                        "type": "boolean",
                        "description": "Whether to include extra, source-specific product attributes in the output. When enabled, the scraper asks IKEA for additional details (such as dimensions, materials, and packaging) and adds them under 'additionalProperties'. Example: enable this to capture material and care information for furniture. This adds more data per product at a small extra time cost. Recommended: on for catalog enrichment, off for the fastest price-and-name-only runs.",
                        "default": false
                    },
                    "maxProductResults": {
                        "title": "Total maximum products",
                        "minimum": 1,
                        "type": "integer",
                        "description": "The maximum total number of products to scrape in one run, across all URLs and keywords combined. The scraper stops once this many products have been saved, so category and keyword inputs never run away. Example: 100. Accepts any positive whole number. Lower values cost less and finish faster; leave empty to scrape everything found. Recommended: start with 50–100 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
