# EUIPO Trademarks Scraper: 100M+ EU/Global Trademarks via TMview (`dltik/euipo-trademarks-scraper`) Actor

Search 100M+ trademarks from EUIPO + 70 IP offices (USPTO, INPI, DPMA, WIPO Madrid). Filter by Nice class, status, office, date. No API key. $0.01/result.

- **URL**: https://apify.com/dltik/euipo-trademarks-scraper.md
- **Developed by:** [Walid](https://apify.com/dltik) (community)
- **Categories:** Business
- **Stats:** 30 total users, 23 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.00005 / actor start

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## EUIPO Trademarks Scraper — 100M+ EU & Global Trademarks (TMview) + AI Brand Clearance

⭐ **Bookmark this actor → [apify.com/dltik/euipo-trademarks-scraper](https://apify.com/dltik/euipo-trademarks-scraper)** — Apify ranks by bookmarks, so it directly drives the visibility of this scraper. **One click. No signup beyond your existing Apify account.**

> Scrape **100M+ trademarks from EUIPO and 70+ national IP offices** (USPTO, INPI France, DPMA Germany, WIPO Madrid, JPO Japan, UKIPO, CNIPA China and more) via the **official TMview backend** (`tmdn.org`) operated by the EU Intellectual Property Office. Filter by Nice class, status, office, application date, mark type — then go further than any other scraper: **AI likelihood-of-confusion brand clearance**, **applicant → company resolution**, **free lifecycle & renewal signals**, and a **scheduled trademark-watch** mode. **No API key, no OAuth, no monthly quota — $0.01 per trademark, the disruptive sweet spot vs $0.10 elsewhere.**

### ✨ What makes this EUIPO trademarks scraper different

| Feature | This scraper | Other EUIPO scrapers |
|---|:---:|:---:|
| Price per result | **$0.01** | $0.05 - $0.10 |
| Coverage (offices) | **70+ IP offices via TMview** | EUIPO-only |
| Full goods & services text (per Nice class) | ✅ *(enrichDetails)* | ❌ / extra fee / needs your OAuth |
| No OAuth / no API key (self-serve) | ✅ | often needs your EUIPO credentials |
| **AI likelihood-of-confusion (brand clearance)** | ✅ *(analyzeClearance)* | ❌ |
| **Free computed conflict score** (phonetic + name + Nice) | ✅ *(referenceMark)* | ❌ |
| **Applicant → company record** (SIREN + size + status) | ✅ *(enrichApplicant)* | ❌ |
| **Free lifecycle signals** (days-to-expiry, opposition window, renewal-due) | ✅ | rare / paid |
| **Trademark watch** (only new/updated marks on a schedule) | ✅ *(incrementalMode)* | ❌ |
| Nice + Vienna classification arrays | ✅ | partial |
| Concurrent detail enrichment (fast on big runs) | ✅ | ❌ |
| Success rate (live 30d) | **100%** | varies |

### What can this EUIPO trademark scraper do?

- 🇪🇺 **100M+ live trademarks** indexed by the EU IP Office's TMview (every active EUIPO trademark + 70+ national IP offices including USPTO, INPI, DPMA, WIPO Madrid)
- 🔎 **Multi-criteria search** — name, Nice class, status, office, mark type, application date range
- 🧠 **AI brand-clearance / likelihood-of-confusion** *(analyzeClearance)* — score every existing mark against a proposed brand name the way an EU examiner would: semantic (meaning) similarity, goods & services conflict, an overall confusion score, a verdict and a recommended action
- 🎯 **Free computed conflict score** *(referenceMark)* — even without AI, every result is scored against your proposed mark: Jaro-Winkler name distance + phonetic match (Metaphone/Soundex) + Nice-class overlap → a 0-100 `computed_conflict_score`
- 🏢 **Applicant → company intelligence** *(enrichApplicant)* — resolve the brand owner to a real company: French applicants to their SIREN + size + sector + active/ceased status, other countries to the matching national company-registry actor
- 📅 **Free lifecycle & renewal signals** — every mark returns `lifecycle_stage`, `days_until_expiry`, `renewal_due_soon`, and an `opposition_open` window with days left — no enrichment needed
- 👀 **Trademark watch** *(incrementalMode)* — schedule it and receive only NEW and UPDATED marks (competitor filings, status changes) since the last run
- 📝 **Full goods & services text** *(enrichDetails)* — the complete descriptive wording per Nice class, the field most EUIPO scrapers omit or hide behind your own OAuth
- 🎨 **Nice + Vienna classification** — numeric Nice classes plus Vienna image codes for figurative/combined marks
- 🚀 **HTTP-only, no API key** — TMview is a free public service from the EUIPO (Apify datacenter proxy is enabled by default to avoid edge IP filtering)

### Brand clearance & likelihood of confusion — the premium wedge

Commercial trademark platforms (Corsearch, CompuMark, Markify) sell likelihood-of-confusion screening for **$300–500 per mark per year**. This actor puts the same core capability behind a single input flag.

Set `referenceMark` to the brand name you want to clear (and optionally `referenceNiceClasses` for the goods/services you'd use it in). Every result then carries a `clearance` object:

- **Free tier** (just `referenceMark`): `mark_similarity` (Jaro-Winkler), `phonetic_match` (Metaphone/Soundex), `nice_overlap`, `computed_conflict_score` (0–100) and a `computed_conflict_band` (high/medium/low/none).
- **AI tier** (`analyzeClearance: true`, paid plans): adds `semantic_similarity` (catches translations & synonyms — "SUN" vs "SOLEIL"), `goods_conflict`, an overall `likelihood_of_confusion`, a `verdict` (clear / caution / high\_risk), a `recommended_action` and one-line `reasoning`.

> ⚖️ Screening triage to prioritise professional review — **not legal advice**.

### What data can you extract per trademark?

Fields marked ⭐ require `enrichDetails: true` (billed as `trademark-detail`). 🏢 requires `enrichApplicant`. 🧠 requires `referenceMark` / `analyzeClearance`. Everything else comes from the base search at $0.01/result.

| Field | Description |
|---|---|
| `st13` | TMview unique global ID (office code + sequential ID) |
| `application_number` | Office-level application number |
| `mark_name` | Verbal element of the mark |
| `mark_type` | `Word`, `Figurative`, `Combined`, `3-D`, `Sound`, `Colour`, `Hologram`, `Motion` |
| `office_code` | Two-letter IP office (`EM` = EUIPO, `FR` = INPI, `DE` = DPMA, `US` = USPTO, `WO` = WIPO, ...) |
| `status` | `Registered`, `Filed`, `Application published`, `Application opposed`, `Ended`, `Expired` ... |
| `lifecycle_stage` | Normalized: `registered` / `pending` / `expired` / `ended` / `unknown` |
| `is_active` | `true` when the mark is registered or still in prosecution |
| `days_until_expiry` | Days from today to expiration (negative if lapsed) — *populated with enrichDetails* |
| `renewal_due_soon` | `true` when expiry is within 180 days |
| `opposition_open` / `opposition_days_left` | Whether the opposition window is still open + days left |
| `application_date` | YYYY-MM-DD |
| `nice_classes` | Array of Nice class numbers (`[9, 38, 41, 42]`) |
| `vienna_codes` | Array of Vienna image classification codes (figurative/combined marks) |
| `applicant_name` / `applicant_names` | Primary applicant + full list |
| `territories_protected` | Country codes where the mark is enforced (Madrid + EU) |
| `mark_image_url` / `mark_thumbnail_url` | TMview-hosted mark image + thumbnail |
| `tmview_url` / `office_record_url` | Deep links to TMview + the originating IP office |
| `scraped_at` | ISO-8601 UTC timestamp |
| ⭐ `registration_number` / `registration_date` / `expiration_date` | Office registration data |
| ⭐ `opposition_period_start` / `opposition_period_end` / `opposition_deadline` | Opposition window dates |
| ⭐ `status_detail` / `status_date` / `kind_mark` | Detailed status + `Individual`/`Collective`/`Certification` |
| ⭐ `goods_and_services` | Array of `{nice_class, description}` — full descriptive wording per class |
| ⭐ `applicants_detail` | Array of `{name, country, address}` |
| ⭐ `representatives` / `renewals` | Legal representative(s) + renewal history |
| 🏢 `applicant_company` | Resolved French company: `siren`, `legal_name`, `naf_code`, `sector`, `employee_range`, `is_active`, `risk_flag` |
| 🏢 `registry_hint` | For non-FR applicants: pointer to the matching national company-registry actor |
| 🧠 `clearance` | `{mark_similarity, phonetic_match, nice_overlap, computed_conflict_score, computed_conflict_band}` + AI `{semantic_similarity, goods_conflict, likelihood_of_confusion, verdict, recommended_action, reasoning}` |

### How to scrape EUIPO trademarks in 5 steps

1. **[Create a free Apify account](https://apify.com/sign-up)** — no credit card required
2. **Open [EUIPO Trademarks Scraper](https://apify.com/dltik/euipo-trademarks-scraper)** on Apify Store
3. **Enter `query`** — brand name or keyword (`apple`, `louis vuitton`, `tesla`)
4. **Optionally filter** — `offices=['EM']`, `niceClasses=[9, 42]`, `statuses=['Registered']`; set `enrichDetails=true` for full dates + goods & services, `enrichApplicant=true` for company data, `referenceMark` + `analyzeClearance=true` for AI clearance
5. **Click Start** — clean JSON in seconds, exportable to CSV / JSON / Excel

### How much does it cost to scrape EUIPO trademarks?

**PAY\_PER\_EVENT — $0.01 per trademark result** ($10 per 1,000). Failed/empty runs are not charged. Optional add-ons are OFF by default and billed only when you enable them:

| Event | When | Price |
|---|---|---|
| `trademark-result` | every mark (identity, status, Nice/Vienna, applicant, **+ free lifecycle & conflict score**) | **$0.01** |
| `trademark-detail` | `enrichDetails` — reg/expiry/opposition dates + full goods & services + representatives + renewals | +$0.01 |
| `applicant-enriched` | `enrichApplicant` — only for applicants resolved to a real company (FR SIREN) | +$0.005 |
| `clearance-analyzed` | `analyzeClearance` — AI likelihood-of-confusion per mark (paid plans) | +$0.02 |

Still far under the $0.05–$0.10 competitors charge for *less* data — and none of them offer AI clearance, applicant intelligence, or watch mode at any price.

| Run size | Trademarks | Base ($0.01) | + Detail ($0.02) | + AI clearance ($0.04) |
|---|---|---|---|---|
| Quick test | 30 | $0.30 | $0.60 | $1.20 |
| Standard | 300 | $3.00 | $6.00 | $12.00 |
| Deep | 1,000 | $10.00 | $20.00 | $40.00 |

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `query` | string | — | Brand name / keyword search (required) |
| `offices` | string\[] | `[]` (all) | Office codes: `EM`, `FR`, `DE`, `US`, `WO`, `JP`, `UK`, ... |
| `statuses` | string\[] | `[]` (all) | `Registered`, `Filed`, `Expired`, `Application published`, ... |
| `niceClasses` | int\[] | `[]` (all) | Nice class numbers `1`-`45` |
| `tmTypes` | string\[] | `[]` (all) | `Word`, `Figurative`, `Combined`, `3-D`, `Sound`, `Colour` |
| `applicationDateFrom` / `applicationDateTo` | string | — | YYYY-MM-DD window |
| `enrichDetails` | boolean | `false` | Full detail per result (dates, goods & services, representatives, renewals). +$0.01/result. Fetched concurrently. |
| `enrichApplicant` | boolean | `false` | Resolve applicant → company (FR SIREN live; other countries → registry pointer). +$0.005/resolved. |
| `referenceMark` | string | — | Proposed brand name to clear → free computed conflict score on every result |
| `referenceNiceClasses` | int\[] | `[]` | Intended Nice classes — sharpens the clearance score |
| `analyzeClearance` | boolean | `false` | AI likelihood-of-confusion vs `referenceMark` (paid plans). +$0.02/mark. |
| `referenceGoods` | string | — | Free-text intended goods/services, for AI clearance context |
| `incrementalMode` | boolean | `false` | Watch mode: only NEW/UPDATED marks on recurring runs |
| `includeUnchanged` / `includeExpired` | boolean | `false` | Also emit unchanged marks / expired markers (watch mode) |
| `stateKey` | string | `default` | Namespace for the watch baseline |
| `detailConcurrency` | integer | 4 | Parallel detail requests (1-8) when `enrichDetails` is on |
| `pageSize` | integer | 30 | TMview page size (1-200) |
| `maxResults` | integer | 30 | 1-5000 |
| `proxyConfig` | object | datacenter | Apify datacenter proxy enabled by default |

### Output example

Record with `enrichDetails` + `enrichApplicant` + `referenceMark: "APPEL"` + `analyzeClearance`:

```json
{
  "st13": "EM500000000000753",
  "mark_name": "APPLE",
  "mark_type": "Word",
  "office_code": "EM",
  "status": "Registered",
  "lifecycle_stage": "registered",
  "is_active": true,
  "days_until_expiry": 3562,
  "renewal_due_soon": false,
  "opposition_open": false,
  "application_date": "1996-04-01",
  "registration_date": "1999-02-03",
  "expiration_date": "2036-04-01",
  "nice_classes": [9, 16, 38, 41, 42],
  "goods_and_services": [
    {"nice_class": 9, "description": "Computers, computer terminals, keyboards ..."}
  ],
  "applicant_name": "Apple Inc.",
  "applicant_company": null,
  "registry_hint": {"country": "US", "registry_actor": "usa-ny-company-registry-scraper", "registry_actor_url": "https://apify.com/dltik/usa-ny-company-registry-scraper"},
  "clearance": {
    "reference_mark": "APPEL",
    "mark_similarity": 0.907,
    "phonetic_match": true,
    "nice_overlap": [9, 42],
    "computed_conflict_score": 88,
    "computed_conflict_band": "high",
    "semantic_similarity": 20,
    "goods_conflict": 90,
    "likelihood_of_confusion": 82,
    "verdict": "high_risk",
    "recommended_action": "avoid",
    "reasoning": "Near-identical spelling and phonetics with heavy Nice-class 9/42 overlap makes confusion likely."
  },
  "tmview_url": "https://www.tmdn.org/tmview/#/tmview/detail/EM500000000000753",
  "scraped_at": "2026-07-01T12:32:01Z"
}
```

### Use cases — trademark watch, brand clearance & IP intelligence

- 🧠 **Brand clearance / naming** — before you file, run your candidate name as `referenceMark` with `analyzeClearance` and get every conflicting mark ranked by likelihood of confusion across EU + national offices
- 👀 **Trademark watch services** — schedule `incrementalMode` on a watchlist and receive only newly-filed or status-changed marks (competitor look-alikes) each day/week
- 🏢 **Brand-owner lead-gen & competitive intel** — `enrichApplicant` turns "who owns this mark" into a full company profile (SIREN, size, sector, active/ceased) — impossible with a trademark-only scraper
- ⚖️ **IP attorney prior-art search** — pull every trademark named `X` across EU + national offices in seconds, ranked by Nice class, with full goods & services text
- 🚨 **Opposition & renewal alerts** — surface every mark whose `opposition_open` window or `renewal_due_soon` flag fires within your horizon
- 📊 **IP portfolio analytics** — aggregate `application_date × office × Nice class × applicant` to map filing trends and competitor portfolios

### Use the EUIPO scraper via API

```python
import requests

run = requests.post(
    "https://api.apify.com/v2/acts/dltik~euipo-trademarks-scraper/run-sync-get-dataset-items",
    headers={"Authorization": "Bearer YOUR_APIFY_TOKEN", "Content-Type": "application/json"},
    json={
        "query": "lumina",
        "offices": ["EM", "FR"],
        "referenceMark": "lumina",
        "referenceNiceClasses": [9, 42],
        "analyzeClearance": True,
        "enrichDetails": True,
        "maxResults": 50
    }
).json()
print(f"Scraped {len(run)} trademarks")
```

### FAQ

**Is this an official EUIPO API?**
TMview (`tmdn.org`) is the official EU Intellectual Property Office trademark search backend, aggregating EUIPO + 70 national IP offices. This scraper hits the same public JSON endpoint the TMview web UI calls — no HTML parsing, no anti-bot circumvention.

**How is the AI likelihood-of-confusion different from the free conflict score?**
The free `computed_conflict_score` (from `referenceMark`) is string-level: Jaro-Winkler distance + phonetic keys + Nice-class overlap. The AI layer (`analyzeClearance`) adds *meaning*: it catches translations, synonyms and conceptual overlap ("SUN"/"SOLEIL"), and it reasons about goods & services conflict the way an EU examiner does. Use the free score to triage cheaply, then AI on the shortlist. It's screening triage, not legal advice.

**What's the difference vs the `nexgendata/euipo-esearch-trademarks` actor?**
Price ($0.01 vs $0.10), coverage (70+ offices vs EUIPO-only), and depth: we return goods & services, opposition data, applicant-company resolution, lifecycle signals and AI clearance — none of which it offers. And we're self-serve (no BYO EUIPO OAuth, unlike the actors that do return goods & services).

**Will TMview rate-limit my runs?**
TMview has a soft ~3-5 req/s limit. Detail enrichment runs through a small concurrent pool with exponential backoff on 429, so even a 5,000-mark enriched run finishes comfortably inside the actor timeout. Datacenter proxy is enabled by default.

**Does the watch mode charge me for everything every run?**
No. In `incrementalMode` only NEW and UPDATED marks are emitted and billed; unchanged marks are skipped (unless you set `includeUnchanged`). That's what makes daily brand monitoring cheap.

***

⭐ **Found this EUIPO Trademarks Scraper useful? [Bookmark it](https://apify.com/dltik/euipo-trademarks-scraper)** — Apify ranks actors by bookmarks, so it's the strongest single signal for Store visibility. One click.

### The dltik IP intelligence suite

Trademarks are one right — cover the whole IP + company graph with the rest of the suite:

| Actor | What it does | Price |
|---|---|---|
| [Espacenet Patents Scraper](https://apify.com/dltik/espacenet-patents-scraper) | 130M patents from EPO (Espacenet) | $0.015/patent |
| [USPTO Patents Scraper](https://apify.com/dltik/uspto-patents-scraper) | US patents via PatentsView | $0.01/patent |
| [Pappers Sirene Scraper](https://apify.com/dltik/pappers-sirene-scraper) | 26M French companies (SIREN/SIRET) — powers `enrichApplicant` | $0.008/result |
| [INPI MCP Server](https://apify.com/dltik/mcp-server-inpi) | French IP (patents/trademarks/designs) for AI agents | $0.01/tool-call |
| [BODACC Scraper](https://apify.com/dltik/bodacc-fr-scraper) | French commercial court announcements | $0.003/record |
| [SEC EDGAR MCP Server](https://apify.com/dltik/mcp-server-sec-edgar) | US public companies for AI agents | $0.01/tool-call |
| [TED Europa Scraper](https://apify.com/dltik/ted-europa-scraper) | EU public procurement tenders | $0.005/tender |
| [Pappers MCP Server](https://apify.com/dltik/mcp-server-pappers) | French company data for Claude / GPT | $0.01/tool-call |

License: MIT · Author: [dltik](https://apify.com/dltik)

# Actor input Schema

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

Free-text search on trademark name. Examples: 'apple', 'louis vuitton', 'tesla', 'volkswagen'. Required to run a search.

## `offices` (type: `array`):

Two-letter IP office codes. Examples: 'EM' = EUIPO (EU trademark), 'FR' = INPI France, 'DE' = DPMA Germany, 'US' = USPTO, 'WO' = WIPO Madrid, 'JP' = JPO Japan. Leave empty to search ALL 70+ offices. Multi-value supported.

## `statuses` (type: `array`):

Filter by status. Common values: 'Registered', 'Filed', 'Expired', 'Application published', 'Application opposed', 'Application refused'. Leave empty for all statuses.

## `niceClasses` (type: `array`):

Nice classification numbers (1-45) — international trademark goods/services categories. Provide as strings: '9' = electronics/software, '25' = clothing, '35' = advertising, '41' = education, '42' = scientific/IT services. Multi-value supported.

## `tmTypes` (type: `array`):

Filter by mark type. Common values: 'Word', 'Figurative', 'Combined', '3-D', 'Sound', 'Colour', 'Hologram', 'Motion'. Leave empty for all types.

## `applicationDateFrom` (type: `string`):

Filter by application date (start). Format: YYYY-MM-DD. Example: '2020-01-01'. Requires applicationDateTo to be set as well.

## `applicationDateTo` (type: `string`):

Filter by application date (end). Format: YYYY-MM-DD. Example: '2026-12-31'. Requires applicationDateFrom to be set as well.

## `enrichDetails` (type: `boolean`):

When ON, fetches the full TMview detail record for EACH result: registration & expiration dates, opposition period start/end, complete goods & services descriptions per Nice class, detailed applicant info (address, nationality), legal representatives, and renewal history. Detail requests run concurrently. Adds one request per result and is billed separately as a 'trademark-detail' event. Leave OFF for fast, cheap name/status/Nice-class search.

## `enrichApplicant` (type: `boolean`):

When ON, resolves each mark's applicant to a real company. French applicants are matched live to their SIREN + size + sector + active/ceased status via the official register (same source as our pappers-sirene-scraper); applicants from 30+ other countries get a pointer to the matching national company-registry actor. Turns trademark data into brand-owner intelligence (lead-gen, competitive mapping, IP due diligence). Billed as 'applicant-enriched' only for applicants successfully resolved to a company record. Best combined with enrichDetails (which provides the applicant's country).

## `referenceMark` (type: `string`):

The proposed brand name you want to CLEAR. When set, every result is scored against it for free: Jaro-Winkler name similarity, phonetic match (Metaphone/Soundex) and Nice-class overlap → a 0-100 computed\_conflict\_score with a band (high/medium/low/none), written into each record's 'clearance' object. Leave empty to skip clearance scoring. Defaults to 'query' when analyzeClearance is ON.

## `referenceNiceClasses` (type: `array`):

The Nice classes (1-45) your proposed mark would be used in. Sharpens the clearance conflict score (a name clash only matters where the goods/services overlap). Provide as strings, e.g. \['9','42']. Optional.

## `analyzeClearance` (type: `boolean`):

When ON, an AI model scores each existing mark against your referenceMark for likelihood of confusion the way an EU examiner would: semantic\_similarity (meaning, not just spelling — catches translations/synonyms), goods\_conflict (overlap of goods & services), an overall likelihood\_of\_confusion 0-100, a verdict (clear/caution/high\_risk), a recommended\_action and one-line reasoning. This is the enterprise brand-clearance feature — screening triage, not legal advice. Billed as 'clearance-analyzed' per mark scored. Requires a paid Apify plan and the account OpenRouter key. Best with enrichDetails ON (feeds the goods & services text to the model).

## `referenceGoods` (type: `string`):

Optional free-text description of the goods/services your proposed mark will cover (e.g. 'mobile software for fitness tracking'). Gives the AI clearance model the context to judge goods conflict. Only used when analyzeClearance is ON.

## `incrementalMode` (type: `boolean`):

When ON, remembers every trademark seen on the previous run (per stateKey) and, on the next run, tags each mark NEW / UPDATED / UNCHANGED. By default only NEW and UPDATED marks are emitted and billed — so scheduling this daily/weekly becomes a trademark-watch that surfaces competitor filings and status changes cheaply. Combine with a schedule for brand monitoring.

## `includeUnchanged` (type: `boolean`):

When incrementalMode is ON, also emit (and bill) marks that did not change since the last run. Leave OFF to receive only the delta.

## `includeExpired` (type: `boolean`):

When incrementalMode is ON, also emit lightweight EXPIRED markers for marks that were present last run but dropped off this run. These markers are metadata and are NOT billed.

## `stateKey` (type: `string`):

Namespace for the incrementalMode baseline, so several saved watches (different queries) keep separate histories under one actor. Any short string, e.g. 'competitor-x' or 'class9-watch'. Defaults to 'default'.

## `detailConcurrency` (type: `integer`):

Number of parallel TMview detail requests when enrichDetails is ON (1-8). Higher finishes large enriched runs faster; the default 4 stays comfortably under TMview's soft rate-limit.

## `pageSize` (type: `integer`):

Results per TMview page. Default 30 matches the official TMview UI. Higher reduces request count for large maxResults.

## `maxResults` (type: `integer`):

Maximum trademarks to return. Start with 30 to validate filters, scale up once happy. Billing is per result returned.

## `proxyConfig` (type: `object`):

Apify datacenter proxy is enabled by default — TMview blocks plain cloud IPs at the network edge. You can switch to residential if you scrape at very high frequency.

## Actor input object example

```json
{
  "offices": [],
  "statuses": [],
  "niceClasses": [],
  "tmTypes": [],
  "enrichDetails": false,
  "enrichApplicant": false,
  "referenceNiceClasses": [],
  "analyzeClearance": false,
  "incrementalMode": false,
  "includeUnchanged": false,
  "includeExpired": false,
  "detailConcurrency": 4,
  "pageSize": 30,
  "maxResults": 30,
  "proxyConfig": {
    "useApifyProxy": true
  }
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("dltik/euipo-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("dltik/euipo-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 '{}' |
apify call dltik/euipo-trademarks-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/FzDQZFz3xYwrc4YvE/builds/FuANG19mQ1nmk5Px0/openapi.json