# Creoate Scraper - Products, Categories & Search Results (`sones/creoate-products-scraper`) Actor

Scrape Creoate products from category URLs and search queries. Extract names, prices, stock, thumbnails, categories, variation labels, flairs, and optional wholesaler data without proxies.

- **URL**: https://apify.com/sones/creoate-products-scraper.md
- **Developed by:** [Samy](https://apify.com/sones) (community)
- **Categories:** E-commerce, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

## Creoate Scraper - Extract products from category pages and search results

Scrape Creoate product data at scale from category URLs and keyword searches.

This Apify actor is built for teams that need fast, structured Creoate data for product research, lead generation, competitor monitoring, catalog enrichment, and wholesale marketplace analysis.

It collects product listings in a lightweight way, which makes it much faster and lighter than a browser-based scraper. No proxy is required.

### What this actor can scrape

- Creoate category pages such as kitchen, stationery, home decor, beauty, gifts, and more
- Creoate search results for keywords such as `notebook`, `candle`, `mug`, or any niche product term
- Product details including product ID, WP ID, product name, slug, categories, prices, discounts, stock, thumbnails, variation labels, and flairs
- Optional wholesaler data including wholesaler ID, name, slug, logo, country, description, rating, minimum order values, and store discount information

### Why use this Creoate actor

- High throughput scraping without browser automation
- Supports both category URLs and search queries in the same run
- No proxy setup needed
- Clean structured dataset output ready for export or downstream automation
- Built for Apify with input schema, dataset schema, output schema, and pay-per-event support

### Typical use cases

- Monitor new products and pricing across Creoate categories
- Build category-level product datasets for wholesale research
- Search Creoate for specific keywords and export matching products
- Track brands, wholesalers, stock levels, and pricing changes over time
- Feed product data into internal dashboards, spreadsheets, or enrichment pipelines

### Input

You can combine category URLs and keyword searches in a single run.

#### Example input

```json
{
  "startUrls": [
    { "url": "https://www.creoate.com/product-category/kitchen-dining" },
    { "url": "https://www.creoate.com/product-category/home-fragrances" }
  ],
  "searchQueries": ["notebook", "candle"],
  "maxProductsPerUrlQuery": 100,
  "enrichBrandData": true,
  "resultsPerPage": 100,
  "maxConcurrency": 10,
  "includeRaw": false
}
````

#### Input fields

- `startUrls` - Creoate category URLs to scrape
- `searchQueries` - keywords to scrape from Creoate search
- `maxProductsPerUrlQuery` - max number of products per category URL and per query
- `enrichBrandData` - include nested wholesaler and brand information
- `resultsPerPage` - products fetched per page, up to `100`
- `maxConcurrency` - number of category/query sources processed in parallel
- `includeRaw` - attach the raw Algolia hit to each item

### Output

Each dataset item contains source metadata plus normalized product data.

#### Main fields

- `sourceType`, `sourceValue`, `sourceUrl`, `searchQuery`, `categorySlug`
- `id`, `WP_id`, `productName`, `productSlug`
- `productCategories`, `productCategoryNames`
- `productPrice`, `productDiscount`, `productBulkDiscount`
- `productInventory`, `productOrderQuantity`, `productMinQuantity`
- `productVariationLabels`, `flairs`
- `productThumbnailUrl`
- `wholesaler` when `enrichBrandData` is enabled

The actor also stores a run summary in the default key-value store under `OUTPUT`.

### Performance notes

- It is optimized for large listing extraction, not browser rendering
- No proxy is used because it is not required for this workflow
- Higher `resultsPerPage` and moderate `maxConcurrency` values usually give the best throughput

### Pricing model

This actor is prepared for Apify pay-per-event monetization.

Recommended pricing events:

- `apify-actor-start`
- `result`

The actor charges one `result` event per pushed product item.

### Local development

Install dependencies:

```bash
bun install
```

Run the quick CLI helper:

```bash
bun run search -- notebook --hits 5
```

Run the actor locally:

```bash
apify run
```

Local input file:

```bash
storage/key_value_stores/default/INPUT.json
```

### Notes

- This actor focuses on product listing extraction, not checkout, login, or retailer-only workflows
- Output order may differ slightly from what the public website renders in some edge cases
- If you need exact downstream formatting, transform the dataset after run completion or request a custom schema update

# Actor input Schema

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

Creoate category URLs to scrape, for example kitchen, stationery, home decor, or other product-category pages.

## `searchQueries` (type: `array`):

Keyword searches to scrape directly from Creoate search results, such as notebook, candle, mugs, or gifts.

## `maxProductsPerUrlQuery` (type: `integer`):

Maximum number of products to collect for each category URL and each search query.

## `enrichBrandData` (type: `boolean`):

Include nested wholesaler and brand metadata such as wholesaler name, country, logo, description, and minimum order values.

## `resultsPerPage` (type: `integer`):

Number of products requested per page. Higher values improve throughput and reduce request overhead.

## `maxConcurrency` (type: `integer`):

How many category URLs and search queries to process in parallel. This actor does not use proxies.

## `includeRaw` (type: `boolean`):

Attach the original raw response object to each dataset item for debugging or custom post-processing.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.creoate.com/product-category/kitchen-dining"
    }
  ],
  "searchQueries": [
    "notebook"
  ],
  "maxProductsPerUrlQuery": 50,
  "enrichBrandData": true,
  "resultsPerPage": 100,
  "maxConcurrency": 10,
  "includeRaw": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.creoate.com/product-category/kitchen-dining"
        }
    ],
    "searchQueries": [
        "notebook"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sones/creoate-products-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.creoate.com/product-category/kitchen-dining" }],
    "searchQueries": ["notebook"],
}

# Run the Actor and wait for it to finish
run = client.actor("sones/creoate-products-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.creoate.com/product-category/kitchen-dining"
    }
  ],
  "searchQueries": [
    "notebook"
  ]
}' |
apify call sones/creoate-products-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Creoate Scraper - Products, Categories & Search Results",
        "description": "Scrape Creoate products from category URLs and search queries. Extract names, prices, stock, thumbnails, categories, variation labels, flairs, and optional wholesaler data without proxies.",
        "version": "0.1",
        "x-build-id": "xCKaKcY7hCoNqLYba"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sones~creoate-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sones-creoate-products-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/sones~creoate-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sones-creoate-products-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/sones~creoate-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sones-creoate-products-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Creoate category URLs to scrape, for example kitchen, stationery, home decor, or other product-category pages.",
                        "default": [
                            {
                                "url": "https://www.creoate.com/product-category/kitchen-dining"
                            }
                        ],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Keyword searches to scrape directly from Creoate search results, such as notebook, candle, mugs, or gifts.",
                        "default": [
                            "notebook"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProductsPerUrlQuery": {
                        "title": "Max Products Per URL/Query",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of products to collect for each category URL and each search query.",
                        "default": 50
                    },
                    "enrichBrandData": {
                        "title": "Enrich Brand Data",
                        "type": "boolean",
                        "description": "Include nested wholesaler and brand metadata such as wholesaler name, country, logo, description, and minimum order values.",
                        "default": true
                    },
                    "resultsPerPage": {
                        "title": "Results Per Page",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of products requested per page. Higher values improve throughput and reduce request overhead.",
                        "default": 100
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many category URLs and search queries to process in parallel. This actor does not use proxies.",
                        "default": 10
                    },
                    "includeRaw": {
                        "title": "Include Raw Hit",
                        "type": "boolean",
                        "description": "Attach the original raw response object to each dataset item for debugging or custom post-processing.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
