# Rituals Scraper — Luxury Body Care & Home Fragrance (`studio-amba/rituals-scraper`) Actor

Scrape luxury body care and home fragrance products from Rituals.com. Shower foams, candles, diffusers, gift sets, and limited editions with prices and details.

- **URL**: https://apify.com/studio-amba/rituals-scraper.md
- **Developed by:** [Jelle Desramaults](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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.

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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Rituals Scraper -- Premium Cosmetics, Body Care & Home Fragrance Data

Scrape product data from Rituals.com -- the Dutch luxury cosmetics and lifestyle brand known for its signature collections like The Ritual of Sakura, Karma, and Hammam. Extract prices, ratings, descriptions, and images from their full product line.

### What is Rituals Scraper?

Rituals Cosmetics is a Netherlands-based premium brand with over 1,000 stores worldwide. They sell body care, skincare, home fragrance (candles, diffusers, room sprays), gift sets, and travel essentials -- all organized around thematic "rituals" collections. This scraper turns their online catalog into structured data.

Common use cases:

- **Beauty & cosmetics price tracking** -- Monitor Rituals' pricing across collections. Track seasonal gift set pricing, limited editions, and value packs.
- **Competitive analysis for premium brands** -- If you sell competing body care or home fragrance products, benchmark against Rituals' positioning, price points, and product range.
- **Product catalog monitoring** -- Detect new product launches, discontinued items, and collection refreshes before they appear in newsletters.
- **Review and rating analysis** -- Rituals products carry customer ratings. Track which products are best-rated and how new launches perform over time.
- **Gift market research** -- Rituals is a major player in the gift set market. Analyze their seasonal offerings, bundle pricing, and packaging strategies.

### What data does Rituals Scraper extract?

Each product record includes:

- 🧴 **Product name** -- full product title with collection name
- 🏷️ **Brand** -- always "Rituals" (useful for multi-brand datasets)
- 💰 **Price** and currency
- 💸 **Original price** -- when items are marked down
- 🔢 **EAN code** -- European Article Number (barcode)
- 📦 **SKU** -- internal product identifier
- ✅ **Stock availability**
- ⭐ **Customer rating** -- average score
- 💬 **Review count** -- number of reviews
- 🖼️ **Product images** -- primary and additional angles
- 📝 **Description** -- product details and fragrance narrative
- 📂 **Category** -- product classification

### How to scrape Rituals.com

#### Search by keyword

Find specific types of products:

```json
{
    "searchQuery": "shower gel",
    "maxResults": 50
}
````

Effective search terms include product types ("candle", "body cream", "gift set") or collection names ("sakura", "karma", "hammam").

#### Browse a category

Target a specific product category:

```json
{
    "categoryUrl": "https://www.rituals.com/en-nl/bath-body/shower",
    "maxResults": 100
}
```

#### Discover the full catalog

Leave both fields empty to let the scraper discover products via the sitemap:

```json
{
    "maxResults": 500
}
```

**Tip:** Rituals organizes products by collection (The Ritual of Sakura, Jing, Karma, etc.) and by type (shower, body, home, etc.). Category URLs are the most targeted way to scrape.

### Output

A typical Rituals product record:

```json
{
    "name": "The Ritual of Sakura Foaming Shower Gel",
    "brand": "Rituals",
    "price": 9.50,
    "currency": "EUR",
    "url": "https://www.rituals.com/en-nl/the-ritual-of-sakura-foaming-shower-gel-1116064.html",
    "scrapedAt": "2025-04-03T11:00:00.000Z",
    "ean": "8719134143652",
    "sku": "1116064",
    "inStock": true,
    "rating": 4.7,
    "reviewCount": 342,
    "imageUrl": "https://www.rituals.com/dw/image/v2/BBKL_PRD/on/demandware.static/Sites-rituals/default/product/1116064.jpg",
    "description": "Transform your daily shower into a moment of mindfulness with this foaming shower gel. Enriched with Rice Milk and Cherry Blossom, the creamy formula gently cleanses while the delicate floral scent uplifts your senses.",
    "category": "Shower"
}
```

### How much does it cost?

| Scenario | Estimated cost |
|----------|---------------|
| 50 products (search) | ~$0.02 |
| 200 products (category) | ~$0.08 |
| Full catalog (~500 products) | ~$0.30 |
| Full catalog + proxy | ~$0.50 |

Rituals has a relatively compact catalog (hundreds, not thousands of products), making full catalog scrapes affordable.

### Can I integrate?

Push Rituals data wherever you need it:

- **Google Sheets** -- live spreadsheet of product prices and ratings
- **Webhooks** -- get notified when new products launch
- **Zapier / Make** -- automate workflows based on price or availability changes
- **Slack** -- alerts for limited edition releases
- **Cloud storage** -- archive product data to S3 or Google Cloud
- **Databases** -- store in PostgreSQL, MySQL, or MongoDB

### Can I use it as an API?

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/rituals-scraper").call(run_input={
    "searchQuery": "candle",
    "maxResults": 20,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['name']} -- EUR {item['price']} ({item.get('rating', 'N/A')} stars)")
```

#### JavaScript

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('studio-amba/rituals-scraper').call({
    searchQuery: 'candle',
    maxResults: 20,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => console.log(`${item.name} -- EUR ${item.price}`));
```

### FAQ

**Can I scrape Rituals stores in other countries?**
The scraper targets the Dutch (`en-nl`) storefront. Rituals operates country-specific sites, but the product catalog is largely identical. Pricing may vary by region.

**Does it capture ingredients or detailed product specs?**
The description field includes the product narrative. Full ingredient lists may be available on some product pages depending on how Rituals structures the data.

**How do I scrape only a specific collection (e.g., Sakura)?**
Use the search query with the collection name: `"searchQuery": "sakura"`. Or use a category URL like `https://www.rituals.com/en-nl/the-ritual-of-sakura`.

**Are gift sets included?**
Yes. Gift sets appear in search results and categories like any other product. Search for "gift set" to target them specifically.

**How frequently does Rituals update their catalog?**
Rituals launches new collections seasonally and updates limited editions periodically. Monthly scraping captures most changes, though weekly catches limited editions faster.

### Limitations

- The scraper targets the Netherlands English storefront (`en-nl`). Other regional storefronts are not directly supported.
- Rituals uses Salesforce Commerce Cloud (Demandware). The site's internal search may behave differently from what you see in a browser.
- Some product pages may not have JSON-LD structured data, in which case the scraper falls back to HTML meta tags with slightly less detail.
- The sitemap discovery mode may include non-product pages that get filtered out automatically.

### Other retail and fashion scrapers

Build a complete picture of the European beauty and retail landscape:

- [ICI PARIS XL Scraper](https://apify.com/studio-amba/iciparisxl-scraper) -- Belgium's leading beauty and perfume retailer
- [Kruidvat Scraper](https://apify.com/studio-amba/kruidvat-scraper) -- Drugstore, beauty, and health products
- [Mytheresa Scraper](https://apify.com/studio-amba/mytheresa-scraper) -- Luxury fashion from 200+ designers
- [Action Scraper](https://apify.com/studio-amba/action-scraper) -- Europe's biggest discount retailer
- [AS Adventure Scraper](https://apify.com/studio-amba/asadventure-scraper) -- Outdoor and adventure gear
- [Bergfreunde Scraper](https://apify.com/studio-amba/bergfreunde-scraper) -- German climbing and hiking equipment
- [Intersport Scraper](https://apify.com/studio-amba/intersport-scraper) -- European sports retail
- [Helly Hansen Scraper](https://apify.com/studio-amba/hellyhansen-scraper) -- Norwegian outdoor and sailing apparel

### Your feedback

Questions, bugs, or feature requests? Reach out through the actor's Apify Store page. We respond quickly and keep this scraper up to date with Rituals' site changes.

# Actor input Schema

## `searchQuery` (type: `string`):

Search for products by keyword (e.g., 'shower gel', 'candle', 'gift set').

## `categoryUrl` (type: `string`):

A rituals.com category page URL to scrape. Example: https://www.rituals.com/en-nl/bath-body/shower. If empty, uses search query.

## `maxResults` (type: `integer`):

Maximum number of products to return.

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

Proxy settings for better reliability on large runs.

## Actor input object example

```json
{
  "searchQuery": "shower gel",
  "maxResults": 100
}
```

# 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 = {
    "searchQuery": "shower gel"
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/rituals-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 = { "searchQuery": "shower gel" }

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/rituals-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 '{
  "searchQuery": "shower gel"
}' |
apify call studio-amba/rituals-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rituals Scraper — Luxury Body Care & Home Fragrance",
        "description": "Scrape luxury body care and home fragrance products from Rituals.com. Shower foams, candles, diffusers, gift sets, and limited editions with prices and details.",
        "version": "0.1",
        "x-build-id": "qZ1kDNkeA1hm2TeFs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~rituals-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-rituals-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/studio-amba~rituals-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-rituals-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/studio-amba~rituals-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-rituals-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for products by keyword (e.g., 'shower gel', 'candle', 'gift set')."
                    },
                    "categoryUrl": {
                        "title": "Category URL",
                        "type": "string",
                        "description": "A rituals.com category page URL to scrape. Example: https://www.rituals.com/en-nl/bath-body/shower. If empty, uses search query."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for better reliability on large runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```