# Trademark Conflict Watch — USPTO & EUIPO New-Filing Alerts (`nexgendata/trademark-conflict-watch`) Actor

- **URL**: https://apify.com/nexgendata/trademark-conflict-watch.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $200.00 / 1,000 conflict / delta matches

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 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

## Trademark Conflict Watch — New-Filing & Conflict Alerts (USPTO + EUIPO)

**Monitor new trademark filings and detect potential conflicts across USPTO and EUIPO before they become a problem.**

This is a monitoring tool, not a one-time search. You give it the marks, owners, and classes you care about; it watches the US and EU trademark systems and tells you what is **new or changed** since the last run — confusingly similar marks, owner overlaps, class overlaps, and status changes — early enough to act within opposition and review windows.

### 1. What this Actor does

On each run it searches the US and EU trademark systems for your watched marks and owners, normalizes the results, classifies each one against your watch criteria, and stores a snapshot. In **delta mode** it emits only what changed since last time. It is built on top of NexGenData's proven USPTO and EUIPO trademark search Actors.

### 2. Who this is for

Trademark attorneys, brand owners, in-house IP teams, ecommerce brands, agencies, founders checking a brand name, and competitive-intelligence teams.

### 3. Recommended setup

**Run once in `full` mode to create your baseline, then schedule daily `delta` runs to monitor new and changed filings.** Full mode shows you everything that currently matches; delta mode then surfaces only what's new or changed each day — which is the way to use this as an ongoing watch. The first time you run a watch query in `delta` mode it records a baseline and emits nothing (this is expected, not an error); every run after that emits only changes.

### 4. What it watches

- **Marks** you specify (`watch_marks`)
- **Owners / applicants** you specify (`owners`)
- **Nice classes** you specify (`classes`)
- Across **US** (USPTO trademark records) and **EU** (EUIPO / TMview records)

### 5. Conflict types

- `exact` — normalized mark equals a watched mark
- `similar` — fuzzy near-match above threshold (only when `similarity_mode` is `fuzzy`)
- `same_owner` — filing's owner matches a watched owner
- `same_class` — filing appears in a watched Nice class
- `owner_match` — an owner query matched, even when the mark itself was not watched

Every match where a comparison was performed carries a `similarity_score`.

### 6. What counts as "changed" (delta mode)

In delta mode you'll be alerted when, versus the last run, any of these happen:

- a **new application** is found (`added`)
- the **status** changed, e.g. Filed → Registered or Opposed (`status_changed`)
- the **owner / applicant** changed (`owner_changed`)
- the **Nice classes** changed (`class_changed`)
- the mark record was otherwise **amended**, e.g. a publication date or registration number was added/changed (`amended`)

Unchanged filings are never re-emitted, so a daily run only shows you what actually moved.

### 7. Input options

| Field | Default | Notes |
|---|---|---|
| `watch_marks` | — | Required unless `owners` or `classes` is given |
| `owners` | `[]` | Owner/applicant names to monitor |
| `classes` | `[]` | Nice classes (1–45) to flag |
| `jurisdictions` | `["US","EU"]` | Which systems to watch |
| `similarity_mode` | `normalized` | `exact` / `normalized` / `fuzzy` (fuzzy is opt-in) |
| `mode` | `delta` | `delta` (changes only) or `full` (all current) |
| `include_raw` | `false` | Attach the raw source record |
| `maxResults` | `25` | Per mark, per jurisdiction |

**First-time users who want immediate results: run `mode: "full"` first** to see all current matches and create your baseline, then switch to `mode: "delta"` for ongoing scheduled monitoring.

### 8. Output fields

`jurisdiction, mark, normalized_mark, owner, classes, status, filing_date, publication_date, application_number, registration_number, source_url, office, conflict_type, conflict_with, similarity_score, change_type, detected_at` (plus `raw` when `include_raw` is true).

### 9. Delta mode vs full mode

- **full** — outputs every current match and refreshes the stored snapshot.
- **delta** — outputs only new/changed matches versus the stored snapshot. The **first** delta run for a given watch query creates a **baseline** (recorded, nothing emitted) and logs that clearly; subsequent runs emit only changes. Snapshots are keyed by a deterministic hash of your marks, owners, classes, jurisdictions and similarity mode.

### 10. Best for / not best for

**Best for:** recurring brand watching · new-filing alerts · owner and class monitoring · early conflict triage.

**Not best for:** legal clearance opinions · guaranteed infringement analysis · replacing a full attorney-reviewed trademark watch service. Treat the output as a prioritized review queue, not a legal conclusion.

### 11. Example use cases

- A brand owner watches their mark + Nice class and gets alerted when a confusingly similar mark is filed.
- An agency watches a client's competitors as `owners` and sees every new filing they make.
- An IP team runs it daily on a schedule and only ever sees changes.

### 12. Example input

```json
{
  "watch_marks": ["AcmeFlow", "Northstar Labs"],
  "owners": ["AcmeFlow Inc."],
  "classes": ["9", "42"],
  "jurisdictions": ["US", "EU"],
  "similarity_mode": "normalized",
  "mode": "delta"
}
````

### 13. Example output

```json
{
  "jurisdiction": "US",
  "mark": "ACMEFLOW",
  "normalized_mark": "acmeflow",
  "owner": "AcmeFlow Inc.",
  "classes": ["9", "42"],
  "status": "live: Published for Opposition",
  "filing_date": "2026-05-30",
  "publication_date": "2026-06-17",
  "application_number": "98765432",
  "registration_number": "",
  "source_url": "https://...",
  "office": "US",
  "conflict_type": "exact",
  "conflict_with": "acmeflow",
  "similarity_score": 1.0,
  "change_type": "status_changed",
  "detected_at": "2026-06-19T16:00:00+00:00"
}
```

### 14. Related NexGenData Actors

- **USPTO Trademark Search** — one-shot USPTO lookups (`trademark-search`)
- **EUIPO eSearch Trademarks** — one-shot EUIPO/TMview lookups (`euipo-esearch-trademarks`)
- **Patent Competitor Watch** *(coming soon)* — the patent counterpart to this Actor

### 15. Source notes

Data comes from the US and EU trademark systems via NexGenData's existing USPTO and EUIPO search Actors. If one jurisdiction is temporarily unavailable, the run still returns results from the other and logs a clear partial-results warning.

### 16. Limitations and legal disclaimer

This Actor is an **alerting and filtering tool, not legal advice**. A `conflict_type` is a signal that something deserves review, not a legal determination of infringement or likelihood of confusion. Coverage, statuses, and dates reflect what the upstream registries publish. Always confirm against the official register and consult a qualified trademark professional before acting.

# Actor input Schema

## `watch_marks` (type: `array`):

Brand/mark names to monitor for new or conflicting filings. Required unless owners or classes is provided.

## `owners` (type: `array`):

Owner / applicant names to monitor. Filings whose owner matches are flagged owner\_match / same\_owner.

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

Nice classification numbers (1-45) to flag. Filings in these classes are flagged same\_class.

## `jurisdictions` (type: `array`):

Which trademark systems to watch. US = USPTO/TMView, EU = EUIPO/TMview.

## `similarity_mode` (type: `string`):

exact = identical normalized mark; normalized = punctuation/diacritic-insensitive; fuzzy = also flag near-matches (opt-in).

## `since` (type: `string`):

ISO date. Reserved for date-scoped backfills.

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

delta = only new/changed matches since the last run (first run creates a baseline). full = all current matches.

## `include_raw` (type: `boolean`):

Attach the raw source record to each output row.

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

Cap on results pulled per mark per jurisdiction.

## Actor input object example

```json
{
  "watch_marks": [
    "Acme"
  ],
  "owners": [],
  "classes": [],
  "jurisdictions": [
    "US",
    "EU"
  ],
  "similarity_mode": "normalized",
  "mode": "delta",
  "include_raw": false,
  "maxResults": 25
}
```

# 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 = {
    "watch_marks": [
        "Acme"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/trademark-conflict-watch").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 = { "watch_marks": ["Acme"] }

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/trademark-conflict-watch").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 '{
  "watch_marks": [
    "Acme"
  ]
}' |
apify call nexgendata/trademark-conflict-watch --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/trademark-conflict-watch",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trademark Conflict Watch — USPTO & EUIPO New-Filing Alerts",
        "version": "0.0",
        "x-build-id": "eRmfNSR8qa09x2F8f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~trademark-conflict-watch/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-trademark-conflict-watch",
                "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/nexgendata~trademark-conflict-watch/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-trademark-conflict-watch",
                "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/nexgendata~trademark-conflict-watch/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-trademark-conflict-watch",
                "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": {
                    "watch_marks": {
                        "title": "Watched Marks",
                        "type": "array",
                        "description": "Brand/mark names to monitor for new or conflicting filings. Required unless owners or classes is provided.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "owners": {
                        "title": "Watched Owners (optional)",
                        "type": "array",
                        "description": "Owner / applicant names to monitor. Filings whose owner matches are flagged owner_match / same_owner.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "classes": {
                        "title": "Watched Nice Classes (optional)",
                        "type": "array",
                        "description": "Nice classification numbers (1-45) to flag. Filings in these classes are flagged same_class.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "jurisdictions": {
                        "title": "Jurisdictions",
                        "type": "array",
                        "description": "Which trademark systems to watch. US = USPTO/TMView, EU = EUIPO/TMview.",
                        "default": [
                            "US",
                            "EU"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "similarity_mode": {
                        "title": "Similarity Mode",
                        "enum": [
                            "exact",
                            "normalized",
                            "fuzzy"
                        ],
                        "type": "string",
                        "description": "exact = identical normalized mark; normalized = punctuation/diacritic-insensitive; fuzzy = also flag near-matches (opt-in).",
                        "default": "normalized"
                    },
                    "since": {
                        "title": "Since (optional)",
                        "type": "string",
                        "description": "ISO date. Reserved for date-scoped backfills."
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "full",
                            "delta"
                        ],
                        "type": "string",
                        "description": "delta = only new/changed matches since the last run (first run creates a baseline). full = all current matches.",
                        "default": "delta"
                    },
                    "include_raw": {
                        "title": "Include Raw Source Record",
                        "type": "boolean",
                        "description": "Attach the raw source record to each output row.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max Results Per Source Query",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Cap on results pulled per mark per jurisdiction.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```