# USPTO Trademark Search — Check If a Phrase Is Trademarked (`actor-forge/uspto-trademark-search`) Actor

Bulk-check phrases against the official US trademark register before you list a T-shirt, mug or Amazon product. Verdict per phrase (registered, pending, dead-only, clear) plus matching marks with owner, classes, goods and TSDR link. $0.03 per phrase.

- **URL**: https://apify.com/actor-forge/uspto-trademark-search.md
- **Developed by:** [ActorForge](https://apify.com/actor-forge) (community)
- **Categories:** Business, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 phrase checkeds

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 Search — Check If a Phrase Is Trademarked

Bulk-check phrases against the official US trademark register before you list a T-shirt, mug or Amazon product. Verdict per phrase (registered, pending, dead-only, clear) plus matching marks with owner, classes, goods and TSDR link. $0.03 per phrase.

**Check if a phrase is trademarked before you put it on a T-shirt, mug, sticker or Amazon listing.** Paste up to 10,000 phrases, slogans or brand names and each one is checked against the **official US trademark register** (the same database behind USPTO Trademark Search). You get one row per phrase with a clear **verdict**: `registered-live` (a live registered mark exists), `pending` (a live application is in examination), `dead-only` (only abandoned, cancelled or expired marks) or `clear` (no matching mark at all). Each row also has the **live, registered, pending and dead match counts** and the matching marks: **word mark, serial and registration number, live/dead status and USPTO status text, filing and registration dates, owner name with state and country, attorney, international classes, goods and services, mark type and drawing type**, plus a direct **TSDR link** to the official case file. Choose **exact**, **contains** or **all-words** matching and narrow by **international class** (e.g. 25 for clothing, 21 for mugs) to see only the marks that matter for your product. Built for **print-on-demand and Merch by Amazon sellers**, Etsy and Redbubble shops, brand namers and agencies that screen many phrases at once. **$0.03 per phrase checked**, about 3× cheaper than the alternative, with no compute bill on top. Invalid phrases, duplicates and failed checks are never charged.

> **Not legal advice.** This actor reports what is on the USPTO register at the moment of the check. A `clear` result does **not** guarantee a phrase is free to use or registrable: unregistered (common-law) rights, state registrations, marks in other countries, design marks without matching text and similar-but-not-identical marks are not covered. Consult a trademark attorney before relying on a result.

📘 **Step-by-step guide:** [How to Check If a Phrase Is Trademarked (USPTO, in Bulk)](https://devtaonas.github.io/actorforge-site/guides/check-if-phrase-is-trademarked-uspto/)

### What data does it return?

Every run outputs clean, schema-validated rows like these:

| phrase | verdict | liveMatchCount | registeredLiveCount | pendingCount | deadMatchCount | matches\[0].owner | matches\[0].internationalClasses |
| --- | --- | --- | --- | --- | --- | --- | --- |
| JUST DO IT | registered-live | 12 | 7 | 5 | 9 | Nike, Inc. | 009, 010, 021, 025 |
| MAMA BEAR | registered-live | 8 | 8 | 0 | 26 | Build-A-Bear Retail Management, Inc. | 028 |
| WEBVAN | dead-only | 0 | 0 | 0 | 13 |  |  |
| COFFEE BEFORE TALKIE | clear | 0 | 0 | 0 | 0 |  |  |

### How much does it cost?

Transparent pay-per-event pricing — you only pay for what you get, and the
actor **always respects your run budget**: set a maximum total charge and it
stops cleanly at the cap instead of overrunning.

| Event | Price | Charged | Worked example |
| --- | --- | --- | --- |
| `phrase-checked` | $0.03 | per phrase checked against the register and delivered (verdict, counts and up to 100 matching marks included) | 1,000 phrases = $30.00 |
| `apify-actor-start` | $0.00005 | per run per GB of memory (platform start fee) | One run at up to 1 GB = $0.00005 (charged as one event) |

### Input options

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `phrases` | array | yes | — | Phrases, slogans or brand names to check against the US trademark register (case and extra spaces do not matter; duplicates are removed). Up to 10,000 per run. |
| `searchMode` | string | no | `"exact"` | exact = the mark text is exactly the phrase (a trailing . or ! is ignored); contains = the phrase appears anywhere inside a mark (CAT LOVER also finds CRAZY CAT LOVERS); words = every word of the phrase appears in the mark, in any order. |
| `statusFilter` | string | no | `"live"` | Which matching marks to list in matches. live = registered or pending marks only (the ones that can block you); all = live and dead; dead = abandoned, cancelled or expired only. The verdict and counts always cover every status. |
| `classes` | array | no | `[]` | Only consider marks in these Nice international classes, e.g. 25 (clothing), 21 (mugs, housewares), 16 (paper goods, stickers, posters), 18 (bags), 9 (phone cases, software). Leave empty to search all classes. |
| `maxResultsPerPhrase` | integer | no | `20` | How many matching marks to list per phrase (live first, then registered marks, newest first). 0 = verdict and counts only. Does not change the price. |

### Limits & honest notes

- Not legal advice. A `clear` verdict means no matching mark text was found on the USPTO register at check time. It does not cover common-law (unregistered) use, state or foreign registrations, design-only marks or confusingly similar marks (e.g. different spelling). Consult a trademark attorney before relying on it.
- Match modes: `exact` = the whole mark text equals the phrase (case-insensitive, a trailing . or ! is ignored); `contains` = the phrase appears anywhere inside the mark text, also inside longer words (CAT LOVER finds CRAZY CAT LOVERS); `words` = every word of the phrase appears in the mark, any order, with very common words such as IT or THE ignored by the USPTO index. When unsure, run `contains`, which is the most cautious.
- The verdict and the live/registered/pending/dead counts always cover every status; `statusFilter` only changes which marks are listed in `matches`. `pending` = live application not (yet) registered; it can still block you.
- The international class filter applies to the verdict too: with classes 25 and 21 a phrase registered only for software (class 9) comes back `clear` for your products.
- Privacy: only the owner's name, entity type and state/country are returned (as published on the public register). Owner street addresses, emails and phone numbers are never returned; for attorneys only the name.
- Gentle on USPTO: at most 2 requests per second with back-off on rate limits, so about 7,000 phrases per hour. For lists over ~6,000 phrases raise the run timeout above the default 1 hour.
- Data comes from the public backend of USPTO Trademark Search (tmsearch.uspto.gov) and is as fresh as that service, usually updated daily. US government data is in the public domain.
- Respects your run budget: set a maximum total charge and the run checks only as many phrases as it covers, stopping cleanly with every delivered row charged exactly once.

### Related ActorForge actors

- [Domain WHOIS & DNS Lookup](https://apify.com/actor-forge/domain-lookup) — check the matching domain
- [UK Companies House Search](https://apify.com/actor-forge/uk-companies-house-search)
- [Image Converter & Compressor](https://apify.com/actor-forge/image-converter)
- **Learn more:** [How to Check If a Phrase Is Trademarked (USPTO, in Bulk)](https://devtaonas.github.io/actorforge-site/guides/check-if-phrase-is-trademarked-uspto/)

### Changelog

- **2026-10-19** — Initial release: bulk phrase check against the US trademark register with verdict (registered-live / pending / dead-only / clear), match counts, matching marks with owner, classes, goods and TSDR link; exact / contains / words modes; class filter.

***

*Built and maintained by **ActorForge**. Reliability first: every actor in the
portfolio is monitored by an automated nightly self-test, and breakages are
typically fixed the same day.*

# Actor input Schema

## `phrases` (type: `array`):

Phrases, slogans or brand names to check against the US trademark register (case and extra spaces do not matter; duplicates are removed). Up to 10,000 per run.

## `searchMode` (type: `string`):

exact = the mark text is exactly the phrase (a trailing . or ! is ignored); contains = the phrase appears anywhere inside a mark (CAT LOVER also finds CRAZY CAT LOVERS); words = every word of the phrase appears in the mark, in any order.

## `statusFilter` (type: `string`):

Which matching marks to list in matches. live = registered or pending marks only (the ones that can block you); all = live and dead; dead = abandoned, cancelled or expired only. The verdict and counts always cover every status.

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

Only consider marks in these Nice international classes, e.g. 25 (clothing), 21 (mugs, housewares), 16 (paper goods, stickers, posters), 18 (bags), 9 (phone cases, software). Leave empty to search all classes.

## `maxResultsPerPhrase` (type: `integer`):

How many matching marks to list per phrase (live first, then registered marks, newest first). 0 = verdict and counts only. Does not change the price.

## Actor input object example

```json
{
  "phrases": [
    "Just Do It"
  ],
  "searchMode": "exact",
  "statusFilter": "live",
  "classes": [],
  "maxResultsPerPhrase": 20
}
```

# Actor output Schema

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

One row per phrase with verdict, match counts and matching marks.

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

One row per matching mark (phrase, mark, status, owner, classes, TSDR link).

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

Phrases checked, verdict counts, invalid inputs and failed checks (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 = {
    "phrases": [
        "Just Do It"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("actor-forge/uspto-trademark-search").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 = { "phrases": ["Just Do It"] }

# Run the Actor and wait for it to finish
run = client.actor("actor-forge/uspto-trademark-search").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 '{
  "phrases": [
    "Just Do It"
  ]
}' |
apify call actor-forge/uspto-trademark-search --silent --output-dataset

```

## MCP server setup

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

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/OZmnNkbIZNIpyFzdv/builds/s1VJ0m2n3vifIteRO/openapi.json