# EUIPO Trademark & Design Search Scraper (`crawlerbros/euipo-trademark-design-search-scraper`) Actor

Search the EU Intellectual Property Office's public eSearch plus register for EU trademarks (EUTM) and registered Community designs (RCD). Look up by number, owner name, or representative name, filter by legal status, Nice classification, mark type, and filing date. No login required.

- **URL**: https://apify.com/crawlerbros/euipo-trademark-design-search-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 1 total users, 0 monthly users, 92.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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 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

## EUIPO Trademark & Design Search Scraper

Search the European Union Intellectual Property Office's public **eSearch plus** register for **EU trademarks (EUTM)** and **registered Community designs (RCD)**. No login, no API key, no cookies required — this actor reads the same public register that powers `euipo.europa.eu/eSearch`.

### What you can search

- **Keyword search** — free-text match against the registration number and the verbal/trademark element
- **Exact number lookup** — full record for one specific EUTM or RCD number
- **Owner / applicant name** — every trademark or design registered to a specific company or person
- **Representative name** — every trademark or design filed through a specific law firm or professional representative
- **Opposition case number** (EU trademarks only) — every trademark tied to a specific opposition proceeding
- **Designer name** (registered designs only) — every design credited to a specific designer/creator

Every name-based/keyword mode works against **both** trademarks and designs — pick which register to search with the `recordType` input. The two case-specific modes (opposition number, designer name) only exist on one register, matching how EUIPO's own data model works.

On top of the search modes, every mode can be narrowed with legal status, mark type/kind, Nice/Locarno classification, design representation means, filing/registration/expiry/publication date windows, and an applicant-reference substring filter — see the Input table below.

### Output fields

| Field | Applies to | Description |
|---|---|---|
| `number` | both | EUTM number (e.g. `000000753`) or RCD number (e.g. `000032776-0001`) |
| `name` | both | Trademark word/verbal element, or design verbal element |
| `applicantName`, `applicantCountry`, `applicantId` | both | Registered owner |
| `representativeName`, `representativeId` | both | Professional representative / law firm of record |
| `status` | both | Current legal status, e.g. `Registered`, `Application published`, `Design lapsed` |
| `markType` | trademark | `Word`, `Figurative`, `3D shape`, `Colour`, `Sound`, etc. |
| `kindMark` | trademark | `Individual`, `Collective`, `EU Certificate` |
| `basis` | trademark | Filing basis, e.g. `EUTM`, incoming/outgoing international registration |
| `niceClasses[]` | trademark | Nice classification numbers |
| `distinctivenessAcquired` | trademark | Whether the mark claims acquired distinctiveness |
| `productIndication` | design | Product description, e.g. "Chairs" |
| `representationMeans` | design | `Static`, `3D`, `Video` |
| `locarnoClass` | design | Locarno classification code, e.g. `09.03` |
| `images[]` | design | `{ imageUrl, thumbnailUrl, viewId }` for every design view |
| `receivingOfficeDate` | design | Date the application was received by the office of first filing, ISO `YYYY-MM-DD` |
| `filingDate`, `registrationDate`, `expiryDate`, `publishedDate` | both | ISO `YYYY-MM-DD` dates |
| `publishedSection` | both | Bulletin section code for the latest publication, e.g. `D.1` |
| `applicantReference` | both | Applicant's own internal filing reference, when supplied |
| `firstLanguage`, `secondLanguage` | both | Filing language and second language declared for the application |
| `publications[]` | both | Bulletin publication history: `{ bulletinDate, bulletinNumber, section, url }` |
| `imageUrl`, `thumbnailUrl` | trademark | Mark representation images, when available |
| `publishedUrl` | both | Link to the official bulletin entry |
| `sourceUrl` | both | Link back into EUIPO's eSearch plus register for this record |
| `recordType`, `scrapedAt` | both | `"trademark"` / `"design"` and the UTC scrape timestamp |

Fields EUIPO doesn't have data for on a given record are simply omitted — no `null`/`"N/A"` placeholders.

### Input

| Field | Type | Applies to | Description |
|---|---|---|---|
| `mode` | select | — | `search` / `byNumber` / `byOwnerName` / `byRepresentativeName` / `byOppositionNumber` / `byDesignerName` |
| `recordType` | select | — | `trademark` or `design` |
| `searchQuery` | string | `search` | Free-text keyword |
| `number` | string | `byNumber` | Exact registration number |
| `ownerName` | string | `byOwnerName` | Case-insensitive substring match |
| `representativeName` | string | `byRepresentativeName` | Case-insensitive substring match |
| `oppositionNumber` | string | `byOppositionNumber` (trademarks only) | Substring match on the opposition case number |
| `designerName` | string | `byDesignerName` (designs only) | Case-insensitive substring match on the designer/creator |
| `status` | select | all modes | Restrict to one legal status |
| `markType` | select | all modes (trademark records only) | Restrict to one mark type |
| `kindMark` | select | all modes (trademark records only) | Restrict to one mark kind |
| `niceClassContains` | select | all modes (trademark records only) | Restrict to one Nice classification class (1–45) |
| `locarnoClass` | select | all modes (design records only) | Restrict to one Locarno classification class (1–32) |
| `representationMeans` | select | all modes (design records only) | Restrict to `Static`, `3D`, or `Video` design representation |
| `applicationReferenceContains` | string | all modes | Substring match on the applicant's own filing reference |
| `filingDateFrom` / `filingDateTo` | date (`YYYY-MM-DD`) | all modes | Restrict to a filing-date window |
| `registrationDateFrom` / `registrationDateTo` | date (`YYYY-MM-DD`) | all modes | Restrict to a registration-date window |
| `expiryDateFrom` / `expiryDateTo` | date (`YYYY-MM-DD`) | all modes | Restrict to an expiry-date window |
| `publishedDateFrom` / `publishedDateTo` | date (`YYYY-MM-DD`) | all modes | Restrict to a publication-date window |
| `maxItems` | integer | all modes | Hard cap on emitted records (1–1000) |
| `proxyConfiguration` | proxy | all modes | Optional — EUIPO does not block datacenter IPs; used only as an automatic fallback |

#### Example: keyword search for EU trademarks

```json
{
  "mode": "search",
  "recordType": "trademark",
  "searchQuery": "apple",
  "maxItems": 50
}
````

#### Example: every registered design owned by a company

```json
{
  "mode": "byOwnerName",
  "recordType": "design",
  "ownerName": "Apple Inc.",
  "status": "Registered and fully published",
  "maxItems": 100
}
```

#### Example: exact trademark lookup

```json
{
  "mode": "byNumber",
  "recordType": "trademark",
  "number": "000000753"
}
```

#### Example: designs by Locarno class and representation type

```json
{
  "mode": "search",
  "recordType": "design",
  "searchQuery": "chair",
  "locarnoClass": "6",
  "representationMeans": "Static",
  "maxItems": 50
}
```

#### Example: trademarks tied to an opposition case

```json
{
  "mode": "byOppositionNumber",
  "recordType": "trademark",
  "oppositionNumber": "0000123"
}
```

### FAQ

**Do I need a EUIPO account or API key?**
No. eSearch plus is a public register; this actor reads the same data anonymously.

**What's the difference between a trademark and a registered Community design?**
A trademark protects a brand name, logo, or other sign used to identify goods/services. A registered Community design (RCD) protects the visual appearance of a product. Set `recordType` to choose which register to search.

**Can I filter by both owner name and legal status at once?**
Yes — `status`, `markType`, `kindMark`, `niceClassContains`, and the filing-date range all combine with any search mode.

**Why did my status filter return 0 results?**
Trademark and design statuses are two separate lists (e.g. `Registered` is a trademark status; `Registered and fully published` is a design status). Make sure the chosen status matches the selected `recordType`.

**Is this the same as TMview?**
It reads from the same underlying EUIPO register that also feeds TMview, but this actor talks directly to the EUIPO eSearch plus service.

**Can I search by opposition case or designer name?**
Yes. `mode=byOppositionNumber` finds every EU trademark tied to a given opposition case number (trademarks only — opposition proceedings don't exist for designs). `mode=byDesignerName` finds every registered design credited to a given designer or creator (designs only). Note that EUIPO's register accepts the designer name as a search filter but doesn't return the matched designer's name on the result record itself.

**Can I filter by Nice or Locarno classification?**
Yes. `niceClassContains` restricts EU trademark results to one of the 45 Nice classification classes; `locarnoClass` restricts registered design results to one of the 32 Locarno classification classes. Both are picked from a dropdown — no need to remember the class number's exact meaning.

### Limitations

A few axes that EUIPO's eSearch plus register exposes are deliberately left out because they can't be reliably supported without extra input the platform doesn't take (a reference image, a Vienna/Locarno figurative-code lookup, or a specific owner/representative-directory number) or don't return usable data through this API:

- **Image similarity search** — eSearch plus supports uploading a logo/design image to find visually similar marks. This requires binary image upload, which isn't a fit for this actor's text-in/JSON-out contract.
- **Vienna classification codes** (figurative element codes, e.g. `03.01.02`) — a controlled vocabulary of thousands of codes normally chosen from an autocomplete widget; not practical as a finite dropdown or a reliable free-text filter.
- **Owner / representative directory search** — eSearch plus has a separate "Owners" and "Representatives" tab that searches entity records directly (with fields like legal form or nationality). This actor searches trademarks and designs, not the entity directories themselves; use `ownerName` / `representativeName` to find the trademarks or designs tied to an owner or representative instead.
- **Priority and seniority claims** — present in EUIPO's data model but not reliably returned by this JSON endpoint across sampled records.

### Data source

All data comes directly from EUIPO's public eSearch plus register (`euipo.europa.eu/eSearch`), the official EU trademark and design database covering registrations since the EU trademark/design systems began.

# Actor input Schema

## `mode` (type: `string`):

Which eSearch plus lookup axis to use.

## `recordType` (type: `string`):

Search EU trademarks (EUTM) or registered Community designs (RCD).

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

Free-text keyword matched against the registration number and the verbal element / trademark name.

## `number` (type: `string`):

Exact EUTM number (e.g. `000000753`) or RCD number (e.g. `000032776-0001`).

## `ownerName` (type: `string`):

Case-insensitive substring match on the registered owner, e.g. `Apple Inc.`. Note: for design records specifically, EUIPO's own API always returns an empty applicant name field (it only exposes an internal applicant ID for designs) — this filter still matches correctly against the underlying owner, the returned design records just won't display the owner's name. Trademark records are unaffected.

## `representativeName` (type: `string`):

Case-insensitive substring match on the professional representative / law firm of record. Note: for design records specifically, EUIPO's own API always returns an empty representative name field (it only exposes an internal representative ID for designs) — this filter still matches correctly, the returned design records just won't display who the representative is.

## `oppositionNumber` (type: `string`):

Find EU trademarks with an opposition case matching this number (substring match). Trademarks only — opposition proceedings don't exist on the design register. Note: the matched trademark record is returned as an ordinary trademark record — it does not include the opposition case's own status/date/parties, since EUIPO's search API doesn't expose that data on the trademark object itself.

## `designerName` (type: `string`):

Find registered designs credited to a designer/creator matching this name (case-insensitive substring match). Designs only. Note: EUIPO's API accepts this as a search filter but does not return the matched designer's name in the result records.

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

Filter to a specific legal status. Trademark and design statuses are separate lists — pick one matching the selected record type.

## `markType` (type: `string`):

Filter trademarks by mark feature/type.

## `kindMark` (type: `string`):

Filter trademarks by legal kind.

## `niceClassContains` (type: `string`):

Restrict to trademarks registered in this Nice classification class (goods & services).

## `locarnoClass` (type: `string`):

Restrict to registered designs in this Locarno classification class (product category).

## `representationMeans` (type: `string`):

Restrict to designs represented as a static image, a 3D model, or a video.

## `applicationReferenceContains` (type: `string`):

Case-insensitive substring match on the applicant's internal filing reference (e.g. `RA/T23221EM`).

## `filingDateFrom` (type: `string`):

Only include records filed on/after this ISO date (`YYYY-MM-DD`).

## `filingDateTo` (type: `string`):

Only include records filed on/before this ISO date (`YYYY-MM-DD`).

## `registrationDateFrom` (type: `string`):

Only include records registered on/after this ISO date (`YYYY-MM-DD`).

## `registrationDateTo` (type: `string`):

Only include records registered on/before this ISO date (`YYYY-MM-DD`).

## `expiryDateFrom` (type: `string`):

Only include records expiring on/after this ISO date (`YYYY-MM-DD`).

## `expiryDateTo` (type: `string`):

Only include records expiring on/before this ISO date (`YYYY-MM-DD`).

## `publishedDateFrom` (type: `string`):

Only include records published on/after this ISO date (`YYYY-MM-DD`).

## `publishedDateTo` (type: `string`):

Only include records published on/before this ISO date (`YYYY-MM-DD`).

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

Hard cap on emitted records.

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

EUIPO's WAF intermittently resets direct requests from datacenter IPs. The actor always tries a direct request first and only falls back to the free Apify AUTO proxy group on failure — no paid proxy groups are used.

## Actor input object example

```json
{
  "mode": "search",
  "recordType": "trademark",
  "searchQuery": "apple",
  "status": "",
  "markType": "",
  "kindMark": "",
  "niceClassContains": "",
  "locarnoClass": "",
  "representationMeans": "",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset containing all scraped EUIPO records.

# 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 = {
    "mode": "search",
    "recordType": "trademark",
    "searchQuery": "apple",
    "status": "",
    "markType": "",
    "kindMark": "",
    "niceClassContains": "",
    "locarnoClass": "",
    "representationMeans": "",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/euipo-trademark-design-search-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 = {
    "mode": "search",
    "recordType": "trademark",
    "searchQuery": "apple",
    "status": "",
    "markType": "",
    "kindMark": "",
    "niceClassContains": "",
    "locarnoClass": "",
    "representationMeans": "",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/euipo-trademark-design-search-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 '{
  "mode": "search",
  "recordType": "trademark",
  "searchQuery": "apple",
  "status": "",
  "markType": "",
  "kindMark": "",
  "niceClassContains": "",
  "locarnoClass": "",
  "representationMeans": "",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/euipo-trademark-design-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/euipo-trademark-design-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EUIPO Trademark & Design Search Scraper",
        "description": "Search the EU Intellectual Property Office's public eSearch plus register for EU trademarks (EUTM) and registered Community designs (RCD). Look up by number, owner name, or representative name, filter by legal status, Nice classification, mark type, and filing date. No login required.",
        "version": "1.0",
        "x-build-id": "jFYkZSJR13aXPfOKH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~euipo-trademark-design-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-euipo-trademark-design-search-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/crawlerbros~euipo-trademark-design-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-euipo-trademark-design-search-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/crawlerbros~euipo-trademark-design-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-euipo-trademark-design-search-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",
                "required": [
                    "mode",
                    "recordType"
                ],
                "properties": {
                    "mode": {
                        "title": "Search mode",
                        "enum": [
                            "search",
                            "byNumber",
                            "byOwnerName",
                            "byRepresentativeName",
                            "byOppositionNumber",
                            "byDesignerName"
                        ],
                        "type": "string",
                        "description": "Which eSearch plus lookup axis to use.",
                        "default": "search"
                    },
                    "recordType": {
                        "title": "Record type",
                        "enum": [
                            "trademark",
                            "design"
                        ],
                        "type": "string",
                        "description": "Search EU trademarks (EUTM) or registered Community designs (RCD).",
                        "default": "trademark"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text keyword matched against the registration number and the verbal element / trademark name.",
                        "default": "apple"
                    },
                    "number": {
                        "title": "Registration number (mode=byNumber)",
                        "type": "string",
                        "description": "Exact EUTM number (e.g. `000000753`) or RCD number (e.g. `000032776-0001`)."
                    },
                    "ownerName": {
                        "title": "Owner / applicant name (mode=byOwnerName)",
                        "type": "string",
                        "description": "Case-insensitive substring match on the registered owner, e.g. `Apple Inc.`. Note: for design records specifically, EUIPO's own API always returns an empty applicant name field (it only exposes an internal applicant ID for designs) — this filter still matches correctly against the underlying owner, the returned design records just won't display the owner's name. Trademark records are unaffected."
                    },
                    "representativeName": {
                        "title": "Representative name (mode=byRepresentativeName)",
                        "type": "string",
                        "description": "Case-insensitive substring match on the professional representative / law firm of record. Note: for design records specifically, EUIPO's own API always returns an empty representative name field (it only exposes an internal representative ID for designs) — this filter still matches correctly, the returned design records just won't display who the representative is."
                    },
                    "oppositionNumber": {
                        "title": "Opposition number (mode=byOppositionNumber)",
                        "type": "string",
                        "description": "Find EU trademarks with an opposition case matching this number (substring match). Trademarks only — opposition proceedings don't exist on the design register. Note: the matched trademark record is returned as an ordinary trademark record — it does not include the opposition case's own status/date/parties, since EUIPO's search API doesn't expose that data on the trademark object itself."
                    },
                    "designerName": {
                        "title": "Designer name (mode=byDesignerName)",
                        "type": "string",
                        "description": "Find registered designs credited to a designer/creator matching this name (case-insensitive substring match). Designs only. Note: EUIPO's API accepts this as a search filter but does not return the matched designer's name in the result records."
                    },
                    "status": {
                        "title": "Legal status",
                        "enum": [
                            "",
                            "Application filed",
                            "Application under examination",
                            "Application published",
                            "Registration pending",
                            "Registered",
                            "Application withdrawn",
                            "Application refused",
                            "Application opposed",
                            "Appeal pending",
                            "Registration cancellation pending",
                            "Registration cancelled",
                            "Registration surrendered",
                            "Registration expired",
                            "Registered and fully published",
                            "Registered and subject to deferment",
                            "Lack of effects",
                            "Design surrendered",
                            "Invalidity procedure pending",
                            "Design declared invalid",
                            "Design lapsed"
                        ],
                        "type": "string",
                        "description": "Filter to a specific legal status. Trademark and design statuses are separate lists — pick one matching the selected record type.",
                        "default": ""
                    },
                    "markType": {
                        "title": "Mark type (trademarks only)",
                        "enum": [
                            "",
                            "Word",
                            "Figurative",
                            "3D shape",
                            "Colour",
                            "Sound",
                            "Hologram",
                            "Motion",
                            "Multimedia",
                            "Olfactory",
                            "Pattern",
                            "Position",
                            "Other"
                        ],
                        "type": "string",
                        "description": "Filter trademarks by mark feature/type.",
                        "default": ""
                    },
                    "kindMark": {
                        "title": "Mark kind (trademarks only)",
                        "enum": [
                            "",
                            "Individual",
                            "Collective",
                            "EU Certificate"
                        ],
                        "type": "string",
                        "description": "Filter trademarks by legal kind.",
                        "default": ""
                    },
                    "niceClassContains": {
                        "title": "Nice classification (trademarks only)",
                        "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"
                        ],
                        "type": "string",
                        "description": "Restrict to trademarks registered in this Nice classification class (goods & services).",
                        "default": ""
                    },
                    "locarnoClass": {
                        "title": "Locarno classification (designs only)",
                        "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"
                        ],
                        "type": "string",
                        "description": "Restrict to registered designs in this Locarno classification class (product category).",
                        "default": ""
                    },
                    "representationMeans": {
                        "title": "Design representation means (designs only)",
                        "enum": [
                            "",
                            "Static",
                            "3D",
                            "Video"
                        ],
                        "type": "string",
                        "description": "Restrict to designs represented as a static image, a 3D model, or a video.",
                        "default": ""
                    },
                    "applicationReferenceContains": {
                        "title": "Applicant's own reference contains",
                        "type": "string",
                        "description": "Case-insensitive substring match on the applicant's internal filing reference (e.g. `RA/T23221EM`)."
                    },
                    "filingDateFrom": {
                        "title": "Filing date from",
                        "type": "string",
                        "description": "Only include records filed on/after this ISO date (`YYYY-MM-DD`)."
                    },
                    "filingDateTo": {
                        "title": "Filing date to",
                        "type": "string",
                        "description": "Only include records filed on/before this ISO date (`YYYY-MM-DD`)."
                    },
                    "registrationDateFrom": {
                        "title": "Registration date from",
                        "type": "string",
                        "description": "Only include records registered on/after this ISO date (`YYYY-MM-DD`)."
                    },
                    "registrationDateTo": {
                        "title": "Registration date to",
                        "type": "string",
                        "description": "Only include records registered on/before this ISO date (`YYYY-MM-DD`)."
                    },
                    "expiryDateFrom": {
                        "title": "Expiry date from",
                        "type": "string",
                        "description": "Only include records expiring on/after this ISO date (`YYYY-MM-DD`)."
                    },
                    "expiryDateTo": {
                        "title": "Expiry date to",
                        "type": "string",
                        "description": "Only include records expiring on/before this ISO date (`YYYY-MM-DD`)."
                    },
                    "publishedDateFrom": {
                        "title": "Publication date from",
                        "type": "string",
                        "description": "Only include records published on/after this ISO date (`YYYY-MM-DD`)."
                    },
                    "publishedDateTo": {
                        "title": "Publication date to",
                        "type": "string",
                        "description": "Only include records published on/before this ISO date (`YYYY-MM-DD`)."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "EUIPO's WAF intermittently resets direct requests from datacenter IPs. The actor always tries a direct request first and only falls back to the free Apify AUTO proxy group on failure — no paid proxy groups are used.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
