# Uspto Trademark Watch (`glistening_film/uspto-trademark-watch`) Actor

- **URL**: https://apify.com/glistening\_film/uspto-trademark-watch.md
- **Developed by:** [Yodesla](https://apify.com/glistening_film) (community)
- **Categories:** Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$20.00 / 1,000 term watcheds

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 Watch: new filings & opposition alerts for your marks

**Schedule this Actor daily or weekly on Apify** and get alerts on **new US trademark
filings** and **marks published for opposition** that match your terms, within a lookback
window (default 7 days) of a snapshot of **live (pending and registered) US federal
trademarks** built from official USPTO bulk data. **$0.02 per term checked, no start fee.**
A record-matching alert, not legal advice, not a clearance and not a complete watch. The
index is refreshed daily from new USPTO filings.

### Use cases

- Watch your own marks (and misspellings of them) for new conflicting filings
- Catch marks **published for opposition** in your space and find out before the
  opposition deadline window closes
- Monitor a set of candidate brand names you may file, on a schedule
- Pair with the USPTO Trademark Lookup Actor: lookup for one-off screening, watch for
  ongoing monitoring

### How it works

Each run looks back `lookbackDays` days (default 7, max 90) and finds marks whose **filing
date** or **last status date** falls in the window. Every watch term is matched against only
those recent rows, so a run is fast and cheap no matter how many terms you watch. If a mark
is currently **published for opposition** (USPTO status `686`), the match is flagged with
`publishedForOpposition: true` — those are the ones with a real deadline.

### Match types

- `exact` (default) — the mark is identical to your term (case- and
  punctuation-insensitive, e.g. "Gold Core" matches "GOLD-CORE").
- `words` (default) — every word of your term appears in the mark, in any order.
- `similar` (default) — near-spellings of your term: the whole mark (spaces ignored) is 1
  character edit away (2 for terms of 9+ letters), or each word of your term appears in a mark
  of similar length with at most a one-letter difference in words of 5+ letters. Catches
  variants like "Gold Core" → "GOLDKORE" / "GOLD CORRE" and "Vibes" → "VIBEZ". Terms shorter
  than 5 letters get exact and word matches only (one-letter variants of short words are
  mostly unrelated marks).

Disable the ones you don't want in `matchTypes`. A mark is reported once, under the
strongest match type it hits (exact > words > similar).

### What you get (one dataset item per term)

`term`, `status` (`ok` or `invalid_input`), `lookbackDays`, `since` (the window start
date), `matchCount`, `matchesCapped`, and `matches[]` — each match has `serial`, `mark`,
`matchType`, `statusCode`, `statusCategory`, `statusDescription`,
`publishedForOpposition`, `filedDate`, `statusDate`, `classes[]`, and a `tsdrUrl` deep
link to the official USPTO TSDR status page. Every item also carries `indexSnapshot`
(the snapshot date) and the disclaimer text.

### Pricing: pay per term checked

**One event per term checked successfully (`status: ok`, $0.02), even with zero matches**
— you paid for the check, not for the hits. **Invalid terms are not charged**, and there is
**no start fee**. The run checks your spending limit before each term and stops cleanly if
it is reached.

### Limits

- Default memory is 2 GB, enough for the maximum 90-day lookback (a 90-day window holds ~760,000
  recent filings). Short lookbacks (7-30 days) also run at 1 GB.

- Max 200 terms per run (duplicates removed); up to 200 matches returned per term
  (`matchesCapped: true` when cut off).

- Lookback window 1-90 days. Schedule at least as often as the window, or older activity
  is only covered if its status changed recently.

- Data is a snapshot of the USPTO bulk files, not a live API; the snapshot date is in
  every result.

### Not legal advice

This is a **record-matching alert**, not legal advice, not a trademark clearance, and not a
complete watch. It only sees live federal marks in the USPTO bulk data: state-law marks,
common-law rights, dead (abandoned/expired/cancelled) marks and foreign marks are **not
included**, and the `similar` matcher is a spelling-distance heuristic, not a
likelihood-of-confusion analysis — phonetic or conceptual lookalikes can be missed, and a
mark filed and then abandoned inside the window may still surface. Consult a trademark
attorney before acting on anything here, e.g. on opposition deadlines.

### FAQ

**Which marks are included?** Live (pending and registered) US federal trademarks from
official USPTO bulk data.

**How fresh is the data?** The index is refreshed daily; the snapshot date
(`indexSnapshot`) is in every result.

**What does it cost?** $0.02 per term checked successfully (even with zero matches), no
start fee; invalid terms are not charged.

**Is this legal advice?** No. See the section above.

### Input example

```json
{
  "watchTerms": ["gold core", "just do it"],
  "classes": ["25"],
  "lookbackDays": 7,
  "matchTypes": ["exact", "words", "similar"]
}
```

# Actor input Schema

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

Trademarks or phrases to watch, max 200 per run. Duplicates are removed.

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

Nice classes 1-45, e.g. 25 = clothing. Only include marks listed in at least one of these classes. Leave empty to watch all classes.

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

How far back (days) to look for new filings and status changes. Schedule the Actor at least as often as this window for full coverage.

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

Which kinds of matches to alert on. Similar = whole mark within 1-2 character edits, or every word (4+ chars) within 1 edit.

## Actor input object example

```json
{
  "watchTerms": [
    "vibes",
    "queen",
    "bloom"
  ],
  "lookbackDays": 7,
  "matchTypes": [
    "exact",
    "words",
    "similar"
  ]
}
```

# Actor output Schema

## `results` (type: `string`):

One item per watched term: term, status (ok or invalid\_input), lookbackDays, since (window start date), matchCount, matchesCapped, matches\[] (serial, mark, matchType, statusCode, statusCategory, statusDescription, publishedForOpposition, filedDate, statusDate, classes\[], tsdrUrl), plus indexSnapshot (the USPTO bulk-data snapshot date) and a disclaimer. Record-matching alert only; not legal advice.

# 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": [
        "vibes",
        "queen",
        "bloom"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("glistening_film/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": [
        "vibes",
        "queen",
        "bloom",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("glistening_film/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": [
    "vibes",
    "queen",
    "bloom"
  ]
}' |
apify call glistening_film/uspto-trademark-watch --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,glistening_film/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/Fgi5xlpcZTBRyvd31/builds/ZXxOMaZFc38dPnY2K/openapi.json