# Kidstuff Australia Toys, Prices & Availability Scraper (`dromb/kidstuff-au-scraper`) Actor

Extract Kidstuff Australia toys, prices in AUD, online availability, brands, barcodes, categories, images, and variants for price monitoring and catalogue research.

- **URL**: https://apify.com/dromb/kidstuff-au-scraper.md
- **Developed by:** [Dmitriy Gyrbu](https://apify.com/dromb) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Kidstuff Australia Toys, Prices & Availability Scraper

Export Kidstuff Australia product data to an Apify Dataset: toy names, brands, prices in AUD, sale prices, online availability, SKUs, barcodes, categories, descriptions, images, and variants. Use it for price monitoring, catalogue research, assortment analysis, or automated Google Sheets and CRM workflows.

This is an unofficial Actor and is not affiliated with or endorsed by Kidstuff.

> Availability reflects the product's online storefront status. It is not a real-time store quantity or location-level inventory reading.

### Quick start

The default input returns a small Dataset of current puzzle products:

```json
{
  "operation": "search",
  "search_query": "puzzle",
  "page": 1,
  "page_size": 10
}
```

A product row can contain:

```json
{
  "id": "...",
  "slug": "jimmy-jack-giant-puzzle-australia",
  "name": "Giant Puzzle Australia",
  "brand": "Jimmy Jack",
  "price": 39.99,
  "current_price": 39.99,
  "currency": "AUD",
  "availability": "in_stock",
  "in_stock": true,
  "source_url": "https://www.kidstuff.com.au/products/jimmy-jack-giant-puzzle-australia",
  "image": "https://cdn.shopify.com/...",
  "images": ["https://cdn.shopify.com/..."]
}
```

Optional fields are returned only when present in Kidstuff's catalogue.

### Supported operations

#### Search products

```json
{
  "operation": "search",
  "search_query": "puzzle",
  "page": 1,
  "page_size": 10,
  "sort": "price_asc"
}
```

#### Discover live category slugs

```json
{ "operation": "categories" }
```

#### Export Educational Toys

```json
{
  "operation": "category",
  "category_slug": "educational-toys",
  "page": 1,
  "page_size": 10,
  "sort": "relevance"
}
```

#### Get product and variant details

```json
{
  "operation": "item",
  "slug": "jimmy-jack-giant-puzzle-australia"
}
```

You can also provide a current product URL:

```json
{
  "operation": "item",
  "url": "https://www.kidstuff.com.au/products/jimmy-jack-giant-puzzle-australia"
}
```

#### Discover filters

```json
{ "operation": "search_filters" }
```

This returns one configuration row containing supported sort options and live category values. Keeping them in one row avoids charging hundreds of duplicate filter records; use `categories` when you want one category per Dataset row.

### Input guide

| Field | Used by | Description |
| --- | --- | --- |
| `operation` | all | `search`, `category`, `item`, `categories`, or `search_filters` |
| `search_query` | search | Product keyword |
| `category_slug` | category | Live slug returned by `categories` |
| `slug` | item | Product handle |
| `url` | item | Current Kidstuff product URL; use instead of `slug` |
| `variant_id` | item | Optional variant to select as the primary result |
| `page` | search, category | Page number starting at 1 |
| `page_size` | search, category | 1–100; the source may return fewer rows |
| `sort` | search, category | Relevance, name, or price order |
| `proxy_configuration` | all | `auto`, `direct`, `apify`, or `residential` |

### Output and run status

Search and category rows remain lightweight. Product details include the richest current fields and a `variants` array where variants exist. Canonical fields include `id`, `slug`, `name`, `brand`, `sku`, `barcode`, `source_url`, `price`, `discount_price`, `current_price`, `currency`, `category`, `availability`, `in_stock`, `description`, `image`, `images`, and `variants`.

Every run also writes an `OUTPUT` record containing status, total rows, errors, selected operation, and actual access route. This makes empty results and failures visible to automations.

### Proxy cost and reliability

`auto` is recommended. It starts with a direct request, which is currently the cheapest and fastest working route, and uses an Apify datacenter proxy only as fallback. Residential Australia is available for diagnostics but costs more. A browser is not required.

### Use with n8n / Make

A practical workflow is:

`Kidstuff Actor → Dataset → n8n or Make → Google Sheets / Telegram / CRM`

Import [`examples/n8n_kidstuff_prices_to_google_sheets.json`](examples/n8n_kidstuff_prices_to_google_sheets.json), configure `APIFY_TOKEN`, connect Google Sheets, and replace the example spreadsheet ID. The workflow starts the Actor, waits for the run, downloads Dataset items, and appends product price rows.

#### Run through the Apify API

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/Kpk4NXiQ8QXi3zxtS/runs?token=YOUR_APIFY_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"operation":"search","search_query":"puzzle","page":1,"page_size":10}'
```

Read `data.defaultDatasetId` from the response and download the rows:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_APIFY_TOKEN&clean=true&format=json"
```

Make can use the same two HTTP calls followed by Google Sheets, Telegram Bot, or a CRM module.

### Limitations

- Kidstuff Australia online catalogue only.
- No store-level stock quantity or real-time inventory guarantee.
- Some collection slugs are seasonal; discover live values with `categories`.
- Result counts and catalogue fields follow the public Kidstuff storefront.
- Large catalogue work should use bounded pages and scheduled runs.

# Actor input Schema

## `operation` (type: `string`):

Choose whether to search products, export a category, retrieve one product, or discover valid categories and filters.

## `search_query` (type: `string`):

Keyword used by Search products. Example: puzzle.

## `category_slug` (type: `string`):

A live collection slug returned by List categories. Example: educational-toys.

## `slug` (type: `string`):

Kidstuff product handle used by Product details. Example: jimmy-jack-giant-puzzle-australia.

## `url` (type: `string`):

A full current Kidstuff product URL. Use either Product slug or Product URL.

## `variant_id` (type: `string`):

Optional Shopify variant ID to select a specific variant in Product details.

## `page` (type: `integer`):

Page number for search or category export.

## `page_size` (type: `integer`):

Maximum results requested for this page. The source can return fewer rows.

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

Optional local sorting for search and category results.

## `proxy_configuration` (type: `string`):

Auto tries the cheapest direct route first. Residential Australia costs more and is intended only as a fallback or diagnostic option.

## Actor input object example

```json
{
  "operation": "search",
  "search_query": "puzzle",
  "page": 1,
  "page_size": 10,
  "sort": "relevance",
  "proxy_configuration": "auto"
}
```

# Actor output Schema

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

Dataset items produced by the selected operation.

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

Status, errors, total rows, selected operation, and actual access route.

# 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 = {
    "search_query": "puzzle"
};

// Run the Actor and wait for it to finish
const run = await client.actor("dromb/kidstuff-au-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 = { "search_query": "puzzle" }

# Run the Actor and wait for it to finish
run = client.actor("dromb/kidstuff-au-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 '{
  "search_query": "puzzle"
}' |
apify call dromb/kidstuff-au-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/Kpk4NXiQ8QXi3zxtS/builds/JaI90HuaGGprSSnea/openapi.json