# IP Australia Trademarks Scraper (`parseforge/ip-australia-trademarks-scraper`) Actor

Export Australian trade marks from IP Australia. Search 3M+ records by word, owner, class, or status. Pull mark number, image, status, Nice classes, and detail-page link for every record.

- **URL**: https://apify.com/parseforge/ip-australia-trademarks-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Other, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.75 / 1,000 result items

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)

## 🇦🇺 IP Australia Trade Marks Scraper

> 🚀 **Export the IP Australia trade marks register in seconds.** Search **3M+ Australian trade marks** by word, owner, Nice class, or status, with the mark image, number, and detail-page link on every record. No login, no manual exports.

> 🕒 **Last updated:** 2026-05-20 · **📊 8 fields** per record · **🏛️ 3M+ marks** · **🔢 45 Nice classes** · **🇦🇺 Australia-wide coverage**

The **IP Australia Trade Marks Scraper** exports records from the **Australian Trade Mark Online Search System (ATMOSS)**, the official register maintained by IP Australia. Each record returns **8 fields**, including the trade mark number, the words or phrase associated with the mark, the assigned Nice classes, the current status, the mark image URL, and a deep link to the official detail page in the same authenticated search session.

The register covers **active, pending, registered, expired, removed, and lapsed marks** across the full **45 Nice classification classes** of goods and services. This Actor handles the ATMOSS session setup, pagination, and image-asset resolution so you can pull a clean dataset into a brand-protection workflow, an attorney's docket, or a competitive intelligence pipeline in minutes.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Trade mark attorneys, IP analysts, brand protection teams, paralegals, market research, naming agencies, journalists | Clearance searches, watch services, competitor monitoring, portfolio audits, Nice class coverage analysis, brand expansion research |

---

### 📋 What the IP Australia Trade Marks Scraper does

Multiple filtering workflows in a single run:

- 🔍 **Word or owner search.** Match against mark text, brand name, or applicant name.
- 🔢 **Nice class filter.** Restrict to one or more of the 45 Nice classes (1 to 45) of goods and services.
- 🚦 **Status filter.** Active, pending, registered, expired, removed, or lapsed.
- 🖼️ **Image asset URLs.** Direct CDN links for word-and-device marks and composite logos.
- 🔗 **Session-aware detail links.** Each record includes a deep link into the live ATMOSS session for one-click human review.

Each record includes the trade mark number, the words or phrase associated with the mark, the assigned Nice classes (or `All`), the status code, the mark image URL when one exists, the detail-page URL, and the ATMOSS search session ID used to generate the link.

> 💡 **Why it matters:** trade mark clearance and watch services demand fresh data, image evidence, and a defensible audit trail. Manual ATMOSS searches do not export, do not paginate cleanly, and break every time the register session expires. This Actor returns the same data the official UI shows, in a structured dataset, every time.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>query</code></td><td>string</td><td><code>"wine"</code></td><td>Mark word, phrase, or owner name. Examples: <code>qantas</code>, <code>red bull</code>, <code>apple</code>.</td></tr>
<tr><td><code>classes</code></td><td>array</td><td><code>[]</code></td><td>One or more Nice classification numbers (1 to 45). Empty = all classes.</td></tr>
<tr><td><code>status</code></td><td>string</td><td><code>""</code></td><td>One of <code>active</code>, <code>pending</code>, <code>registered</code>, <code>expired</code>, <code>removed</code>, <code>lapsed</code>. Empty = any.</td></tr>
</tbody>
</table>

**Example: registered marks for "qantas" across all classes.**

```json
{
    "maxItems": 50,
    "query": "qantas",
    "status": "registered"
}
````

**Example: active wine-related marks in Nice class 33 (alcoholic beverages).**

```json
{
    "maxItems": 200,
    "query": "wine",
    "classes": ["33"],
    "status": "active"
}
```

> ⚠️ **Good to Know:** the `detailUrl` and `imageUrl` fields are tied to the live ATMOSS search session. Detail links remain clickable for a limited time after the run while the session is fresh. For long-term archival, capture the `trademarkNumber` and re-query ATMOSS directly.

***

### 📊 Output

Each trade mark record contains **8 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼️ `imageUrl` | string | null | `"https://cdn2.search.ipaustralia.gov.au/-9006218/TRADE_MARK/S6089480/1.0/S6089480.MEDIUM.JPG"` |
| 🔢 `trademarkNumber` | string | `"-9006218"` |
| 🔤 `words` | string | `"OIRSA REPUBLICA DE EL SALVADOR..."` |
| 🔢 `classes` | string | `"All"` |
| 🚦 `status` | string | `"ACTIVE"` |
| 🔗 `detailUrl` | string | `"https://search.ipaustralia.gov.au/trademarks/search/view/-9006218?s=..."` |
| 🧭 `searchSessionId` | string | `"da41e517-ccd1-4169-8185-36cdf5c0dfdb"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-20T22:15:24.236Z"` |

#### 📦 Sample records

<details>
<summary><strong>🏛️ Composite mark with image: OIRSA emblem</strong></summary>

```json
{
    "trademarkNumber": "-9006218",
    "words": "OIRSA REPUBLICA DE EL SALVADOR EN LA AMERICA CENTRAL DIOS UNION LIBERTAD 15 SEPTIEMBRE DE 1821 REPUBLICA DE NICARAGUA AMERICA CENTRAL REPUBLICA DE COSTA RICA SUB UMBRA FLOREO DIOS PATRIA LIBERTAD REPUBLICA DOMINICANA",
    "classes": "All",
    "status": "ACTIVE",
    "imageUrl": "https://cdn2.search.ipaustralia.gov.au/-9006218/TRADE_MARK/S6089480/1.0/S6089480.MEDIUM.JPG",
    "detailUrl": "https://search.ipaustralia.gov.au/trademarks/search/view/-9006218?s=da41e517-ccd1-4169-8185-36cdf5c0dfdb",
    "searchSessionId": "da41e517-ccd1-4169-8185-36cdf5c0dfdb",
    "scrapedAt": "2026-05-20T22:15:24.236Z"
}
```

</details>

<details>
<summary><strong>🔤 Word mark: navigational aids organisation</strong></summary>

```json
{
    "trademarkNumber": "-9006217",
    "words": "The International Organization for Marine Aids to Navigation",
    "classes": "All",
    "status": "ACTIVE",
    "imageUrl": null,
    "detailUrl": "https://search.ipaustralia.gov.au/trademarks/search/view/-9006217?s=da41e517-ccd1-4169-8185-36cdf5c0dfdb",
    "searchSessionId": "da41e517-ccd1-4169-8185-36cdf5c0dfdb",
    "scrapedAt": "2026-05-20T22:15:24.311Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🇦🇺 | **Official ATMOSS data.** 3M+ Australian trade marks pulled from the live IP Australia register. |
| 🔢 | **45 Nice classes.** Filter by one or many classes of goods and services for tightly scoped clearance searches. |
| 🖼️ | **Mark image URLs.** Word-and-device marks come back with the CDN image link so logos can be downloaded directly. |
| 🔗 | **Session-aware deep links.** Detail URLs open the live ATMOSS detail page for one-click human review. |
| ⚡ | **Fast.** 5 records in 4 seconds, 100 records under a minute. |
| 🔁 | **Always fresh.** Every run reads the current ATMOSS register. New applications and status changes appear immediately. |
| 🚫 | **No login.** Works with the public ATMOSS surface. No account, no API key. |

> 📊 ATMOSS is the source of truth for Australian trade marks. Accurate snapshots feed every clearance opinion, every watch alert, and every brand-protection enforcement letter.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ IP Australia Trade Marks Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **3M+** Australian marks | **Live per run** | query, classes, status | ⚡ 2 min |
| Manual ATMOSS searches | Free | Per-query only, no export | Manual | UI filters | 🐢 Hours per batch |
| Commercial IP watch platforms | $5,000+/year | Global, enriched | Daily | Many | ⏳ Onboarding |
| In-house ATMOSS scraper | Engineering cost | Whatever you build | Whatever you maintain | Whatever you build | 🕒 Weeks |

Pick this Actor when you want repeatable, structured ATMOSS exports without the engineering cost.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the IP Australia Trade Marks Scraper page on the Apify Store.
3. 🎯 **Set input.** Enter a query (mark word or owner), pick Nice classes if needed, choose a status, and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### ⚖️ Trade Mark Attorneys

- Clearance searches across Nice classes
- Watch alerts for newly filed marks
- Conflict reviews for proposed brand names
- Portfolio renewal triage by status

</td>
<td width="50%" valign="top">

#### 🏷️ Brand Protection

- Counterfeit-name surveillance
- Lookalike-mark detection feeds
- Cross-class infringement audits
- Owner-name watchlists

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📊 IP Analysts & Strategy

- Competitor portfolio mapping
- Industry filing trends by Nice class
- M\&A IP due diligence baselines
- Geographic expansion benchmarks

</td>
<td width="50%" valign="top">

#### 🎨 Naming Agencies

- Availability checks at scale before pitches
- Class coverage planning for new launches
- Image-asset libraries for design briefs
- Word-mark uniqueness scoring

</td>
</tr>
</table>

***

### 🔌 Automating IP Australia Trade Marks Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Daily or weekly watch runs keep brand-protection dashboards in sync automatically.

***

### 🌟 Beyond business use cases

Trade mark data powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Innovation-economics studies on filing trends
- Linguistic research on brand naming patterns
- IP-law coursework with real ATMOSS data
- Comparative IP studies across jurisdictions

</td>
<td width="50%">

#### 🎨 Personal and creative

- Indie-brand naming research before launch
- Hobbyist trade mark trackers
- Design portfolios of historic Australian logos
- Brand-history blogs and explainers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Watchdog reporting on opportunistic filings
- Public-domain mark mapping
- Indigenous-name protection research
- Trade-mark misuse investigations

</td>
<td width="50%">

#### 🧪 Experimentation

- Train mark-similarity ML models
- Prototype brand-availability chatbots
- Test OCR on logo image extracts
- Validate Nice-class classification models

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20IP%20Australia%20Trade%20Marks%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20IP%20Australia%20Trade%20Marks%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20IP%20Australia%20Trade%20Marks%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20IP%20Australia%20Trade%20Marks%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Enter a query (word, phrase, or owner), optionally pick Nice classes and a status, click Start, and the Actor opens an ATMOSS search session, paginates the results, and emits a clean structured record per mark.

#### 📏 How accurate is the data?

Every field is read directly from the live ATMOSS surface. The `imageUrl` points to the IP Australia CDN, and the `detailUrl` opens the official ATMOSS detail page for the mark.

#### 🔁 How often is the dataset refreshed?

ATMOSS updates continuously as applications are filed, examined, and acted on. Every run of this Actor reads the register live, so new applications and status changes appear immediately.

#### 🖼️ Does every record have an image?

No. Pure word marks have no image and return `imageUrl: null`. Word-and-device marks, logos, and composite marks return a direct CDN URL to the mark image.

#### 🔢 How do Nice classes work?

The Nice classification organises goods and services into 45 numbered classes. Class 33 covers alcoholic beverages, class 25 clothing, class 9 software and electronics, etc. Pass any combination as an array.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor daily, weekly, or on any cron expression. Pair with webhooks to push new filings into a brand-watch Slack channel.

#### ⚖️ Is this data legal to use?

The ATMOSS register is published as public information by IP Australia. Standard searching, analysis, and brand-protection use is generally accepted. Review IP Australia's terms for redistribution.

#### 💼 Can I use this data commercially?

Yes. The register is open and intended to be searched by businesses, attorneys, and the public. Standard commercial intelligence and watch-service use is supported.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and unlocks scheduling and larger datasets.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. Partial datasets from failed runs are preserved so you never lose progress.

#### 📑 Can I export to CSV or Excel?

Yes. The Dataset tab exports to CSV, Excel, JSON, and XML, with field selection if you only need a subset.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

IP Australia Trade Marks Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe trade mark data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh ATMOSS records into your IP docket, or alert your team in Slack the moment a competitor files a new mark.

***

### 🔗 Recommended Actors

- [**🇺🇸 USPTO Trademark Search Scraper**](https://apify.com/parseforge/uspto-trademark-search-scraper) - US Patent and Trademark Office records
- [**🇪🇺 EUIPO Trade Marks Scraper**](https://apify.com/parseforge/euipo-trademarks-scraper) - European Union trade marks
- [**🏛️ ASIC Companies Scraper**](https://apify.com/parseforge/asic-companies-scraper) - Australian company register
- [**📊 USPTO Patent Search Scraper**](https://apify.com/parseforge/uspto-patent-search-scraper) - US patent filings and grants
- [**🌐 WIPO Global Brand Database Scraper**](https://apify.com/parseforge/wipo-global-brand-database-scraper) - Worldwide mark records

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more IP and regulatory scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by IP Australia or the Australian Government. All trademarks mentioned are the property of their respective owners. Only publicly available register information is collected.

# Actor input Schema

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

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

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

Mark word, phrase, or owner name. Example: 'qantas', 'red bull', 'apple'.

## `classes` (type: `array`):

Filter by one or more Nice classification numbers (1-45). Leave empty for all classes.

## `status` (type: `string`):

Filter by trade mark status.

## Actor input object example

```json
{
  "maxItems": 10,
  "query": "wine"
}
```

# Actor output Schema

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "IP Australia Trademarks Scraper",
        "description": "Export Australian trade marks from IP Australia. Search 3M+ records by word, owner, class, or status. Pull mark number, image, status, Nice classes, and detail-page link for every record.",
        "version": "1.0",
        "x-build-id": "4obJywAqWmxj4UQeL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~ip-australia-trademarks-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-ip-australia-trademarks-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~ip-australia-trademarks-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-ip-australia-trademarks-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~ip-australia-trademarks-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-ip-australia-trademarks-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": {
                    "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"
                    },
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Mark word, phrase, or owner name. Example: 'qantas', 'red bull', 'apple'."
                    },
                    "classes": {
                        "title": "Nice Classes",
                        "type": "array",
                        "description": "Filter by one or more Nice classification numbers (1-45). Leave empty for all classes.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5",
                                "6",
                                "7",
                                "8",
                                "9",
                                "10",
                                "11",
                                "12",
                                "13",
                                "14",
                                "15",
                                "16",
                                "17",
                                "18",
                                "19",
                                "20",
                                "21",
                                "22",
                                "23",
                                "24",
                                "25",
                                "26",
                                "27",
                                "28",
                                "29",
                                "30",
                                "31",
                                "32",
                                "33",
                                "34",
                                "35",
                                "36",
                                "37",
                                "38",
                                "39",
                                "40",
                                "41",
                                "42",
                                "43",
                                "44",
                                "45"
                            ]
                        }
                    },
                    "status": {
                        "title": "Status",
                        "enum": [
                            "",
                            "active",
                            "pending",
                            "registered",
                            "expired",
                            "removed",
                            "lapsed"
                        ],
                        "type": "string",
                        "description": "Filter by trade mark status."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
