# Catch Australia Marketplace Scraper (`parseforge/catch-com-au-scraper`) Actor

Browse Catch.com.au product listings across Australia and pull title, brand, price, rating, review count, image, SKU, seller, stock, and category. Useful for AU price monitoring, retailers benchmarking against the Catch marketplace, and ecommerce analysts watching Australian demand.

- **URL**: https://apify.com/parseforge/catch-com-au-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Automation, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 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.
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.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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🛒 Catch.com.au Australian Marketplace Scraper

> 🚀 **Export Catch.com.au product listings in seconds. Search by keyword, filter by category and price, and get clean structured data for the Australian marketplace.**

> 🕒 **Last updated:** 2026-05-29 · **📊 13 fields** per record · Australian marketplace · Electronics, fashion, home, grocery

The Catch.com.au Scraper turns Australia's [Catch](https://www.catch.com.au) marketplace into a clean, structured dataset. Pass a search query or category, and the actor paginates through the public search endpoint and returns one row per product.

Coverage spans Catch's full marketplace: electronics, fashion, home, kitchen, sports, toys, beauty, and grocery, including third-party sellers.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| 🛍️ Retail analysts | Track AU marketplace pricing and assortment |
| 📦 Brand managers | Monitor brand presence across Catch |
| 💼 Resellers | Identify pricing gaps and trending SKUs |
| 📊 Data teams | Feed competitive intel into BI dashboards |

### 📋 What the Catch.com.au Scraper does

- Calls the public Catch.com.au search endpoint with your query, category, and price filters.
- Paginates through all matching products up to your `maxItems`.
- Normalizes fields (title, brand, price, rating, reviews, seller, stock, category, image, SKU, URL).
- Exports as CSV, Excel, JSON, JSONL, XML, RSS, or HTML.

> 💡 **Why it matters:** Catch.com.au is one of Australia's largest marketplaces, with millions of SKUs from thousands of sellers. Manually monitoring competitor pricing or assortment is impractical at scale.

### 🎬 Full Demo

_🚧 Coming soon._

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Required</th><th>Description</th></tr>
<tr><td><code>query</code></td><td>string</td><td>No</td><td>Search keyword.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>No</td><td>Free users: 10. Paid users: up to 1,000,000.</td></tr>
<tr><td><code>category</code></td><td>string</td><td>No</td><td>Category slug.</td></tr>
<tr><td><code>minPrice</code> / <code>maxPrice</code></td><td>integer</td><td>No</td><td>Price range in AUD.</td></tr>
<tr><td><code>sort</code></td><td>enum</td><td>No</td><td>relevance, price-asc, price-desc, newest, rating.</td></tr>
</table>

**Example 1 — Search headphones:**
```json
{ "query": "headphones", "maxItems": 50, "sort": "price-asc" }
````

**Example 2 — Category browse:**

```json
{ "category": "electronics", "maxItems": 100, "minPrice": 50, "maxPrice": 500 }
```

> ⚠️ **Good to Know:** Catch.com.au serves Australian customers and pricing is in AUD. Results reflect public marketplace listings only.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | string | Primary product image. |
| 🏷️ `title` | string | Product title. |
| 🏭 `brand` | string | Brand name. |
| 🔖 `sku` | string | Catch SKU / product ID. |
| 💲 `price` | number | Current price. |
| 💱 `currency` | string | Always AUD. |
| ⭐ `rating` | number | Average customer rating. |
| 💬 `reviews` | number | Number of reviews. |
| 🛍️ `seller` | string | Seller / merchant name. |
| 📦 `stock` | string | Stock status. |
| 🗂️ `category` | string | Category path. |
| 🔗 `url` | string | Product page URL. |
| 🕒 `scrapedAt` | string | When the row was fetched. |
| ❌ `error` | string | Set on upstream errors. |

**Sample record:**

```json
{
  "imageUrl": "https://s.catch.com.au/.../product.jpg",
  "title": "Sony WH-1000XM5 Wireless Headphones",
  "brand": "Sony",
  "sku": "8123456",
  "price": 499.0,
  "currency": "AUD",
  "rating": 4.7,
  "reviews": 1280,
  "seller": "Catch",
  "stock": "in_stock",
  "category": "Electronics > Audio > Headphones",
  "url": "https://www.catch.com.au/product/sony-wh-1000xm5-8123456",
  "scrapedAt": "2026-05-29T12:00:00.000Z",
  "error": null
}
```

### ✨ Why choose this Actor

| 🇦🇺 | Built for Catch's Australian marketplace, AUD pricing, AU stock. |
| 🧹 | Clean field names ready for Excel, BigQuery, Sheets. |
| 🔌 | Search + category + price filters all exposed. |
| 🛟 | Surfaces errors as clean records, never crashes. |
| 💾 | One-click export to CSV, Excel, JSON, XML, JSONL. |

### 📈 How it compares to alternatives

| Approach | Setup time | AU pricing | Pagination | Marketplace sellers |
|---|---|---|---|---|
| Manual browsing | hours | ✅ | ❌ | ✅ |
| Generic scraper | 1 hr config | partial | partial | partial |
| **This Actor** | 5 sec | ✅ | ✅ | ✅ |

### 🚀 How to use

1. Click **Try for free**.
2. Enter a `query` (e.g. `headphones`) or `category` slug.
3. Optionally set `minPrice`, `maxPrice`, `sort`, and `maxItems`.
4. Click **Start**. Download as CSV, Excel, JSON, or XML.

### 💼 Business use cases

**📊 Competitive pricing.** Snapshot competitor SKU prices every morning.

**🏷️ Brand monitoring.** Track where your brand sits on the marketplace, by rating and seller.

**📦 Assortment analysis.** Map which categories Catch is doubling down on.

**🛍️ Reseller research.** Find gaps in pricing and shipping speed.

### 🔌 Automating Catch.com.au Scraper

- **Make / Zapier**: trigger a daily run, push to Airtable or Google Sheets.
- **Cron schedule**: native Apify scheduler.
- **Webhooks**: notify Slack on completion.
- **Pipe to BigQuery / Snowflake / Postgres**.

### 🌟 Beyond business use cases

**🎓 Academic research.** Study marketplace dynamics in the Australian retail sector.

**🧪 Personal projects.** Track a wishlist of items for price drops.

**🤝 Consumer advocacy.** Audit pricing claims across sellers.

**🧰 Prototyping.** Spin up an e-commerce demo dataset in seconds.

### 🤖 Ask an AI assistant about this scraper

Drop this README into ChatGPT, Claude, or any AI assistant and ask it to map your workflow to the actor's inputs.

### ❓ Frequently Asked Questions

**❓ Do I need an account?** No, the data is publicly accessible.

**❓ Is the price always in AUD?** Yes, Catch is an Australian marketplace.

**❓ How fresh is the data?** Real-time at each run.

**❓ Can I filter by category?** Yes, pass a `category` slug.

**❓ Can I sort by price?** Yes, set `sort` to `price-asc` or `price-desc`.

**❓ Are marketplace sellers included?** Yes, both Catch first-party and third-party.

**❓ Is there pagination?** Automatic, up to `maxItems`.

**❓ Can I schedule runs?** Yes, via Apify's scheduler.

**❓ What format can I download?** CSV, Excel, JSON, JSONL, XML, RSS, HTML.

**❓ Is it official?** No, ParseForge is independent.

### 🔌 Integrate with any app

Native integrations with Make, Zapier, Slack, Discord, Google Drive, Google Sheets, Gmail, Airbyte, Keboola, Telegram, GitHub, and any REST API or webhook endpoint.

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [ParseForge OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database. |
| [ParseForge Alpha Vantage Scraper](https://apify.com/parseforge/alpha-vantage-public-scraper) | Market data, FX, crypto. |
| [ParseForge collection](https://apify.com/parseforge) | 900+ production scrapers. |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 900+ production-grade scrapers.

***

**Disclaimer:** This actor scrapes only publicly available data. ParseForge is not affiliated with, endorsed by, or sponsored by Catch.com.au. Users are responsible for complying with the target site's terms of service. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp).

# Actor input Schema

## `query` (type: `string`):

Keyword search (e.g. 'laptop', 'shoes', 'kitchen'). Leave empty to browse by category.

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `category` (type: `string`):

Optional category slug from Catch URL path (e.g. 'electronics', 'home', 'fashion').

## `minPrice` (type: `integer`):

Minimum price filter in AUD.

## `maxPrice` (type: `integer`):

Maximum price filter in AUD.

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

Sort order for results.

## Actor input object example

```json
{
  "query": "headphones",
  "maxItems": 10,
  "sort": "relevance"
}
```

# Actor output Schema

## `results` (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 = {
    "query": "headphones",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/catch-com-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 = {
    "query": "headphones",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/catch-com-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 '{
  "query": "headphones",
  "maxItems": 10
}' |
apify call parseforge/catch-com-au-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Catch Australia Marketplace Scraper",
        "description": "Browse Catch.com.au product listings across Australia and pull title, brand, price, rating, review count, image, SKU, seller, stock, and category. Useful for AU price monitoring, retailers benchmarking against the Catch marketplace, and ecommerce analysts watching Australian demand.",
        "version": "0.1",
        "x-build-id": "HkcqhIaU83cglPUYf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~catch-com-au-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-catch-com-au-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/parseforge~catch-com-au-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-catch-com-au-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/parseforge~catch-com-au-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-catch-com-au-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": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword search (e.g. 'laptop', 'shoes', 'kitchen'). Leave empty to browse by category."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "category": {
                        "title": "Category slug",
                        "type": "string",
                        "description": "Optional category slug from Catch URL path (e.g. 'electronics', 'home', 'fashion')."
                    },
                    "minPrice": {
                        "title": "Min price (AUD)",
                        "type": "integer",
                        "description": "Minimum price filter in AUD."
                    },
                    "maxPrice": {
                        "title": "Max price (AUD)",
                        "type": "integer",
                        "description": "Maximum price filter in AUD."
                    },
                    "sort": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "price-asc",
                            "price-desc",
                            "newest",
                            "rating"
                        ],
                        "type": "string",
                        "description": "Sort order for results.",
                        "default": "relevance"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```