# USPTO Trademark Watch: New Filings for Your Brand (`reaperoak/uspto-trademark-watch-new-filings`) Actor

Get alerted to new US trademark filings that match your brand, product name or slogan. Schedule it and each run reports only filings it has not shown you before, by class, with owners and links.

- **URL**: https://apify.com/reaperoak/uspto-trademark-watch-new-filings.md
- **Developed by:** [Owais Khan](https://apify.com/reaperoak) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $17.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 for Your Brand

### What is the USPTO Trademark Watch?

It is an Apify Actor that monitors new US trademark filings for the names and slogans you care about. Find out when someone files a US trademark that matches your brand, product name or slogan. Schedule this Actor to run daily or weekly and each run reports only the **filings it has not told you about before**.

Built for small brands, print-on-demand sellers, agencies and founders who want an early warning. Trademark opposition windows are short, and the earlier you see a conflicting filing, the more options you have.

### What you get

For every new filing: the watched term, **severity**, the filed wording, how it relates to your term, status, whether it is registered or pending, owner, serial and registration numbers, classes, filing date, a goods description, and a link to the USPTO record.

| Severity | Meaning |
|---|---|
| **HIGH** | The filed wording is identical to your term. |
| **MEDIUM** | The filed mark contains your term, or sits inside it (two or more words). |

### How to monitor new trademark filings for your brand

1. Enter the brand names or phrases to watch.
2. Choose the classes you care about, or leave them empty to watch every class.
3. Run it once to see the last few months of filings.
4. Create a **Schedule** (daily or weekly) and connect the output to email, Slack, Make, n8n or Zapier.

### How it works

- Add the brand names or phrases you want to watch and, optionally, the classes you care about (25 for clothing, 9 for software, 35 for retail services and so on). Leave classes empty to watch every class.
- The first run looks back as many days as you choose (default 90) so you see what has been filed recently.
- Every later run reports only marks it has not reported before, per term and class selection. USPTO can take several days to load a filing, so each run also re-checks the week before the previous run.
- Schedule it in Apify (Schedules) and connect the output to email, Slack, Make, n8n or Zapier with a webhook.

### Input

```json
{
    "terms": ["dog mom", "my brand name"],
    "classes": ["25", "21"],
    "lookbackDays": 365,
    "onlyNew": true
}
```

### How much does trademark monitoring cost?

You pay per watched term per run, plus a small charge for each new filing reported. A quiet week costs only the term checks.

| Setup | Approximate cost |
|---|---|
| 1 term, weekly | about $0.09 a month before any filings |
| 5 terms, daily | about $3 a month before any filings |
| Each new filing reported | $0.02 |

Paid Apify plans get tiered discounts, and you can set a maximum cost per run. You can try it on Apify's free plan without a card.

### Frequently asked questions

**How soon do I see a new filing?** USPTO can take several days to load a filing, so each run also re-checks the week before the previous run. Nothing is reported twice.

**Why did my first run return so many results?** The first run looks back as many days as you set (default 90). Later runs report only new filings.

**What is the difference between HIGH and MEDIUM?** HIGH means the filed wording is identical to your term. MEDIUM means it contains your term or sits inside it.

### Read this

- **This is a monitoring aid, not legal advice.** It does not tell you whether a filing infringes your rights or what to do about it. Ask a trademark attorney.
- It covers **live US federal** applications and registrations only. It does not cover state marks, other countries, or look-alike wording such as misspellings and sound-alikes.
- Only filings that overlap your term as whole words are reported, so a brand that is a single common word can match a lot.
- Data comes from the public USPTO trademark search. If USPTO changes its response format the run **fails with an error** instead of returning empty results, and the Actor is health-checked every night.

# Actor input Schema

## `terms` (type: `array`):

One per line, up to 120 characters. You are told about new live filings that are identical to, contain, or sit inside the term.

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

Only filings in these classes are reported. Leave empty to watch every class.

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

On the first run for a term, report matching filings from this many days back. Later runs report only filings not reported before.

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

Remembers what each term has already reported and returns only new filings. Turn this on when you schedule the Actor. Off by default so a first manual run always shows results.

## `includeOwners` (type: `boolean`):

Owner names come from public USPTO records.

## Actor input object example

```json
{
  "terms": [
    "dog mom"
  ],
  "lookbackDays": 365,
  "onlyNew": true,
  "includeOwners": true
}
```

# Actor output Schema

## `filings` (type: `string`):

One row per new filing: term, severity (HIGH for identical wording, MEDIUM for overlapping), wording, owner, status, classes, filing date, goods and a USPTO link.

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

For each watched term: the date window searched, how many new filings were reported, and how many live marks matched.

# 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 = {
    "terms": [
        "dog mom"
    ],
    "lookbackDays": 365,
    "onlyNew": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("reaperoak/uspto-trademark-watch-new-filings").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 = {
    "terms": ["dog mom"],
    "lookbackDays": 365,
    "onlyNew": False,
}

# Run the Actor and wait for it to finish
run = client.actor("reaperoak/uspto-trademark-watch-new-filings").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 '{
  "terms": [
    "dog mom"
  ],
  "lookbackDays": 365,
  "onlyNew": false
}' |
apify call reaperoak/uspto-trademark-watch-new-filings --silent --output-dataset

```

## MCP server setup

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

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/ScVLbPi2av8bpHHKT/builds/gyJ4CTr69VKFBCXV5/openapi.json