# USPTO Trademark Monitoring · Similar Marks & Deadlines (`thequietstack/uspto-trademark-watch`) Actor

Trademark monitoring for new US trademark filings and publications similar to yours (a USPTO trademark watch): exact, contains, sound-alike and edit-distance matching with a 0-100 score and reason, Nice class and date filters, opposition deadline, onlyNew for schedules. Only matches are charged.

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

## Pricing

from $30.00 / 1,000 matched trademarks

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## USPTO Trademark Monitoring · Similar Marks & Deadlines

**Trademark monitoring for the USPTO:** a trademark watch that flags new US filings similar to your mark, with a similarity score and the opposition deadline.

**USPTO Trademark Watch** tells you when someone files or publishes a **US trademark that looks or sounds like
yours** - early enough to oppose it. A trademark monitoring service for the price of the matches it finds.

You give it your marks (`NIKE`, `JUST DO IT`, ...). It checks the official USPTO trademark search index for new applications or for marks published for opposition in your date window, scores every candidate against your mark, and returns only the close ones - with the reason, the Nice classes, the owner, the status and, once a mark is published, the **opposition deadline**.

Run it on a schedule with **onlyNew** and every conflicting mark is reported and charged **once**.

### What you get

- One row per **similar US trademark**: mark, 0-100 similarity score, match reason in plain words, owner,
  attorney, serial number, Nice classes, goods and services, status, filing date.
- For published marks: **publication date, opposition deadline, days left** and whether the window is open.
- A link to the official TSDR record of every mark.
- A `SUMMARY` per watch term: candidates in the index, checked, above threshold, written, and everything skipped.

### Use cases

- **Brand owners**: a weekly watch on your own marks instead of a paid watch subscription.
- **Trademark attorneys and IP agencies**: one scheduled task per client (`seenStoreName` per client) and a list
  of conflicting filings with deadlines for the next client report.
- **Brand clearance before filing**: run a new name with `dateField: filed` and a long `lookbackDays` to see
  close recent filings.
- **Marketplace sellers**: spot look-alike filings in your product classes before they are registered.

### What it does

- **Two watch modes**
  - `filed` - new applications by filing date. The earliest warning: months before the opposition period opens.
  - `published` - marks published for opposition in the Official Gazette, **including publications USPTO has already scheduled** for the coming weeks. Each row carries the publication date and the derived opposition deadline.
- **Similarity with a reason you can read** - every row has a 0-100 `similarity` and a `matchReason`:

  | Score | Reason | Example (watching `NIKE`) |
  |---|---|---|
  | 100 | `exact` | `N.I.K.E`, `Nike` |
  | 95 | `exact` | the term equals one of USPTO's own pseudo-mark readings (`NITE` -> `NIGHT`) |
  | 90 | `contains` | `NIKE GRIND` |
  | 85 | `contains` | `GOGOONIKE` |
  | 85 | `phonetic` | `NYKEE`, `NIKO` (same consonant sounds **and** same first vowel sound - `NUKE` is not phonetic) |
  | 80 | `phonetic` | `NYKE SPORT` (one word sounds alike) |
  | <90 | `levenshtein` | `NIKLE` = 80, `BIKE` = 75 (1 - edit distance / longer length) |

  `matchDetail` says exactly why (`mark contains "NIKE" as a whole word`, `edit distance 1 on "NIKEE"`).
- **Nice class filter** (1-45), **live marks only** (default), **ignore your own company** as owner.
- **onlyNew** - remembers reported serial numbers per watch term in a named key-value store.
- **Hard limits** - `maxResults` across all terms, `maxResultsPerTerm`, and `maxCostUsd` computed from the live price. Closest matches are written first.

### Input

```json
{
    "watchTerms": ["NIKE", "JUST DO IT"],
    "dateField": "published",
    "lookbackDays": 30,
    "lookaheadDays": 60,
    "niceClasses": [25, 28, 35],
    "minSimilarity": 80,
    "excludeOwners": ["Nike, Inc"],
    "onlyNew": true,
    "maxResults": 200,
    "maxCostUsd": "5"
}
```

| Field | Default | Meaning |
|---|---|---|
| `watchTerms` | - | Your marks. At least 2 letters/digits each. Duplicates (`Nike` / `NIKE`) are merged. |
| `dateField` | `filed` | `filed` (filing date) or `published` (publication for opposition). |
| `lookbackDays` / `lookaheadDays` | 30 / 60 for published, 0 for filed | Window around today. `dateFrom` / `dateTo` (YYYY-MM-DD) override it. |
| `niceClasses` | all | Only marks in at least one of these classes. |
| `minSimilarity` | 80 | 80 keeps `NIKEE` and `NYKE` but drops `BIKE`, `LIKE`, `NUKE`. |
| `matchTypes` | all four | `exact`, `contains`, `phonetic`, `levenshtein`. |
| `liveOnly` | true | Skip abandoned / cancelled / expired marks. |
| `excludeOwners` | - | Part of an owner name, case-insensitive. Those rows are neither written nor charged. |
| `onlyNew` + `seenStoreName` | false | Report each serial number once per watch term. Use one store name per client. |
| `maxResults` | 200 | Hard cap per run, all terms together. |
| `maxCandidatesPerTerm` | 1000 | USPTO hits scored per term (by relevance). Free. SUMMARY flags `truncated` if more existed. |
| `maxCostUsd` | - | Spending cap for this run from the live per-match price. |

### Output

One row per matching mark, closest first. Real row from a platform run on 01.10.2026 (watch term NIKE, published window; goods and services shortened):

```json
{
    "watchTerm": "NIKE",
    "mark": "NIKE GRIND",
    "similarity": 90,
    "matchReason": "contains",
    "matchDetail": "mark contains \"NIKE\" as a whole word",
    "owner": "Nike, Inc. (CORPORATION; Oregon, USA)",
    "serialNumber": "99685691",
    "registrationNumber": null,
    "filedDate": "2026-03-05",
    "niceClasses": [28, 27, 19],
    "goodsAndServices": "IC 028: [ ... ] | IC 027: [ ... ]",
    "status": "PUBLISHED FOR OPPOSITION",
    "live": true,
    "publishedForOppositionDate": "2026-09-08",
    "oppositionDeadline": "2026-10-08",
    "oppositionWindow": "open",
    "daysUntilDeadline": 7,
    "sourceUrl": "https://tsdr.uspto.gov/#caseNumber=99685691&caseSearchType=US_APPLICATION&caseType=DEFAULT&searchType=statusSearch",
    "checkedAt": "2026-10-01T09:42:50.305Z"
}
```

Also in each row: `pseudoMarks`, `ownerAddress`, `attorney`, `registrationDate`, `statusCode`, `markType`, `drawingType`, `filingBasis`, `dataLoadedAt`, and `firstSeenAt` with onlyNew.

**Opposition deadline** = publication date + 30 days (15 U.S.C. 1063(a)). It is the *first* deadline: extensions of time to oppose can be requested before it runs out, and it is shown only when USPTO has a publication date - never guessed. `oppositionWindow` is `not published yet`, `upcoming`, `open` or `closed`.

The run summary (`SUMMARY` in the key-value store) lists per term how many candidates the index had, how many were checked, how many passed the threshold and how many were written - plus failed terms, empty windows, own filings, duplicates and already-seen marks.

### How much does it cost?

Pay per event. Platform usage is included; you pay only for matching marks that are written to the dataset.

| Event | Charged when | Price |
|---|---|---|
| `trademark-match` ("Matched trademark") | one row is written to the dataset | $0.03 |
| Actor start | once per run | $0.00005 |

Examples:

- **1,000 matches** = **$30**.
- **Weekly watch of 10 marks** with `onlyNew`, finding 3 new conflicting filings that week = **$0.09**.
  A week with nothing new costs only the Actor start.
- A one-off clearance check of 1 name with 40 close marks above `minSimilarity` = **$1.20**.

**Never charged:** terms with no candidates in the window, failed searches, candidates below `minSimilarity`, your own filings (`excludeOwners`), duplicates across terms, marks already reported (`onlyNew`). Use `maxResults` and `maxCostUsd` for a hard ceiling.

### Limits - read before relying on it

- **US only (USPTO).** EUIPO, UKIPO, WIPO, DPMA and TMview were tested on 01.10.2026 and are not reachable without an account, an API key or a captcha - so they are not included.
- **Word marks only.** Design/logo similarity is not checked; marks without a word element are skipped (counted in SUMMARY).
- **Data freshness:** USPTO reloads the search index daily (about 09:20 UTC); filings show up roughly one business day after filing.
- **Similarity is lexical and phonetic, not legal.** It does not judge likelihood of confusion, relatedness of goods or famous-mark status. Pick classes and threshold for your case; a lower threshold means more rows to review.
- **Polite access:** one request at a time, at most about one per second, with backoff. The search is not a bulk-download channel; this Actor makes targeted queries per watch term.
- **Bot protection is never bypassed.** If USPTO answers with a WAF challenge, a captcha or an HTML page instead of data, the Actor stops the whole run at once (status FAILED with a clear message, `SUMMARY.blocked` names the term, remaining terms are listed under `notReachedBecauseBlocked`). No header tricks, no proxy or IP rotation, no retries. Rows written before the stop stay in the dataset; nothing is charged for the blocked term or anything after it.

### Use it via API, integrations and AI agents

```bash
curl -X POST "https://api.apify.com/v2/acts/thequietstack~uspto-trademark-watch/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"watchTerms":["NIKE"],"dateField":"published","lookbackDays":30,"maxResults":20}'
```

Python (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("thequietstack/uspto-trademark-watch").call(run_input={
    "watchTerms": ["NIKE", "JUST DO IT"], "dateField": "published",
    "niceClasses": [25, 28], "onlyNew": True, "seenStoreName": "client-acme",
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["mark"], row["similarity"], row["matchReason"], row["oppositionDeadline"])
```

- **Schedules**: a weekly Apify Schedule with `onlyNew: true` is a complete watch service.
- **Integrations**: send new matches to Slack, email, Google Sheets, Make, Zapier or n8n via the integrations tab.
- **AI agents (MCP)**: `https://mcp.apify.com?tools=thequietstack/uspto-trademark-watch`.

### FAQ

**Which offices are covered?** Only the USPTO (United States). EUIPO, UKIPO, WIPO, DPMA and TMview were tested and
need an account, an API key or a captcha, so they are not included.

**How fresh is the data?** USPTO reloads its search index daily (about 09:20 UTC). New filings usually appear about one
business day after filing; every row carries `dataLoadedAt`.

**How is the opposition deadline calculated?** Publication date + 30 days (15 U.S.C. 1063(a)). It is shown only when
USPTO has a publication date, never guessed. Extensions can be requested before it runs out.

**Does it compare logos?** No. Word marks only; marks without a word element are skipped and counted in `SUMMARY`.

**Is a high score a legal conflict?** No. The score is lexical and phonetic. Likelihood of confusion depends on goods,
classes and more; ask a trademark attorney before acting.

**I watch my own brand. Will my own filings show up?** Add your company to `excludeOwners`; those rows are neither
written nor charged.

**Do I need a USPTO API key?** No. The Actor reads the public trademark search index without login or key.

### Data source, license and legal

- **Source:** USPTO Trademark Search (tmsearch.uspto.gov), the index behind the public search page. No login and no API key are used.
- **License:** USPTO trademark records are works of the U.S. Government and not subject to copyright in the United States (17 U.S.C. 105). Attribution: "Source: United States Patent and Trademark Office". This Actor is not affiliated with or endorsed by the USPTO.
- **USPTO usage policy:** USPTO may block clients that generate unusually high request volumes; keep watch lists and windows reasonable. For bulk data USPTO offers its Open Data Portal (API key required).
- **Not legal advice.** The deadlines are derived from the publication date as a convenience. Always confirm dates and status in TSDR and with a trademark attorney before acting.

# Actor input Schema

## `watchTerms` (type: `array`):

Your marks or brand names. Each one is checked against new US filings or publications in the date window. Example: NIKE, JUST DO IT.

## `dateField` (type: `string`):

'filed' = new applications by filing date (earliest warning, months before opposition opens). 'published' = marks published for opposition in the Official Gazette, including scheduled upcoming publications - this is the one with an opposition deadline.

## `lookbackDays` (type: `integer`):

Window start = today minus this many days. Ignored when 'Date from' is set. For a daily schedule with onlyNew, 7 is plenty.

## `lookaheadDays` (type: `integer`):

For 'published': also include publications already scheduled up to this many days ahead. Default 60 for 'published', 0 for 'filed'.

## `dateFrom` (type: `string`):

Optional fixed window start. Overrides 'Look back'.

## `dateTo` (type: `string`):

Optional fixed window end.

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

Only marks filed in at least one of these international classes (1-45). Empty = all classes. Example: 25 (clothing), 9 (software), 35 (retail).

## `minSimilarity` (type: `integer`):

100 exact · 95 equals a USPTO pseudo-mark reading · 90 contains as a word · 85 contains inside a word / sounds alike · 80 one word sounds alike · below 90 also edit distance. 80 keeps NIKEE and NYKE but drops BIKE and NUKE.

## `matchTypes` (type: `array`):

Which reasons count as a match.

## `liveOnly` (type: `boolean`):

Skip abandoned, cancelled and expired marks.

## `excludeOwners` (type: `array`):

Your own company names (case-insensitive, part of the name is enough), so your own filings are not reported or charged.

## `onlyNew` (type: `boolean`):

Remembers reported serial numbers per watch term in a named key-value store. Use with a schedule: each mark is reported and charged once.

## `seenStoreName` (type: `string`):

Named key-value store for onlyNew. Use a different name per client or watch list.

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

Hard cap on matches written and charged in this run, across all terms. Closest matches are written first.

## `maxResultsPerTerm` (type: `integer`):

Optional cap per watch term.

## `maxCandidatesPerTerm` (type: `integer`):

How many USPTO search hits (by relevance) are scored per term. Free - only matches are charged. If SUMMARY says 'truncated', raise it or narrow the window/classes. Max 10,000.

## `maxCostUsd` (type: `string`):

Optional hard spending cap for this run, computed from the live per-match price. The run stops cleanly before the next match would exceed it.

## Actor input object example

```json
{
  "watchTerms": [
    "NIKE"
  ],
  "dateField": "filed",
  "lookbackDays": 30,
  "minSimilarity": 80,
  "matchTypes": [
    "exact",
    "contains",
    "phonetic",
    "levenshtein"
  ],
  "liveOnly": true,
  "onlyNew": false,
  "seenStoreName": "uspto-trademark-watch-seen",
  "maxResults": 200,
  "maxCandidatesPerTerm": 1000
}
```

# Actor output Schema

## `matches` (type: `string`):

One row per similar US mark with similarity score, reason and opposition deadline.

## `summary` (type: `string`):

Per watch term: candidates in the index, checked, above threshold, written. Failed terms, empty windows, own filings, duplicates and already-seen marks - none of them charged.

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

// Run the Actor and wait for it to finish
const run = await client.actor("thequietstack/uspto-trademark-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 = { "watchTerms": ["NIKE"] }

# Run the Actor and wait for it to finish
run = client.actor("thequietstack/uspto-trademark-watch").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "watchTerms": [
    "NIKE"
  ]
}' |
apify call thequietstack/uspto-trademark-watch --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thequietstack/uspto-trademark-watch"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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