# USPTO Trademark Search (`magnova/uspto-trademark-search`) Actor

Search U.S. federal trademarks from the official USPTO database — wordmark, owner, international class, live/dead status, filing dates, goods/services. No API key, no login, no registration: uses the public backend behind the USPTO's own Trademark Search site, with automatic version discovery.

- **URL**: https://apify.com/magnova/uspto-trademark-search.md
- **Developed by:** [Magnova](https://apify.com/magnova) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 trademark record fetcheds

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 — Apify Actor

Search U.S. federal trademarks from the official USPTO database: wordmark, owner, international class, live/dead status, filing dates, goods/services. **No API key, no login, no registration** — the Actor uses the public backend behind the USPTO's own Trademark Search website, discovered dynamically from the site's configuration.

### What it does

- **Brand clearance research** — search for a wordmark across all live federal trademarks before you file or launch.
- **Competitor / owner watch** — find every mark owned by a company.
- **New-filing monitoring** — combine `filedAfter` with a scheduled run to watch for newly filed marks matching your criteria.
- **Class filtering** — restrict to an international class (e.g. `009` for software).

Each dataset record contains: `serialNumber`, `wordmark`, `status` (LIVE/DEAD), `owner`, `filedDate`, `registrationDate`, `registrationNumber`, `internationalClasses`, `goodsAndServices`, `markType`, and a `tsdrUrl` linking to the official TSDR status page.

Attorney names are deliberately excluded from output (personal-data minimization). Owner names are the applicant of record in a public federal database and are kept, since they are the core of brand research.

### Input

| Field | Description |
|---|---|
| Wordmark / brand text | e.g. `OPENAI` — searches the combined mark wording |
| Owner name | e.g. `Nike, Inc.` |
| Serial number | 8-digit USPTO serial, e.g. `97054561` |
| International class | 1–3 digits, e.g. `009` |
| Mark status | `live` (default), `dead`, or `any` |
| Filed after / before | `YYYY-MM-DD` date filters |
| Advanced query | Raw field-tag query passed straight to the backend, e.g. `CM:"APPLE" AND IC:009 AND LD:true`. Tags: `CM` mark text, `ON` owner, `IC` class, `LD` live/dead, `FD` filing date, `SN` serial, `RN` registration. Overrides the other filters. |
| Max results | 1–5,000 (default 100) |

### How it works

1. Reads `https://tmsearch.uspto.gov/configuration.json` to resolve the current versioned search backend (the same discovery the official UI performs — USPTO rotates versions, so this is never hard-coded).
2. Posts an Elasticsearch-style query to the backend's `tmsearch` endpoint with polite 1-second pacing between pages and automatic retries on rate limits.
3. Maps hits to clean, flat records and pushes them to the dataset.

### Pricing

Pay-per-event: **$0.004 per trademark record** delivered. Runs with no matching marks are not charged.

### Legal notes

- Data source is the USPTO's public trademark database — public federal records.
- No scraping of the website UI: the Actor talks to the backend service the UI itself uses, at a polite request rate.
- Results are trademark *candidates* for research, not legal advice. For filing decisions, consult a trademark attorney and verify through TSDR.

### Development

```bash
python3 -m venv .venv && .venv/bin/pip install -r requirements.txt
.venv/bin/python -m pytest tests/ -q
```

# Actor input Schema

## `filedAfter` (type: `string`):

Only marks filed on or after this date. Format YYYY-MM-DD, e.g. 2026-01-01. Useful for monitoring newly filed marks.

## `filedBefore` (type: `string`):

Only marks filed on or before this date. Format YYYY-MM-DD.

## `internationalClass` (type: `string`):

International trademark class, 1-3 digits, e.g. 009 for software/electronics, 025 for clothing.

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

Maximum number of trademark records to return.

## `owner` (type: `string`):

Filter by trademark owner name, e.g. "Nike, Inc.".

## `query` (type: `string`):

Advanced: raw field-tag query passed straight to the USPTO backend, e.g. CM:"APPLE" AND IC:009 AND LD:true. Tags: CM (mark text), ON (owner), IC (class), LD (live/dead), FD (filing date), SN (serial), RN (registration). Overrides the other filters.

## `serialNumber` (type: `string`):

Look up one specific mark by its 8-digit serial number, e.g. 97054561.

## `status` (type: `string`):

Live marks are active; dead marks are abandoned, cancelled or expired.

## `wordmark` (type: `string`):

Brand text to search for, e.g. "OPENAI". Searches the combined mark wording.

## Actor input object example

```json
{
  "maxResults": 100,
  "status": "live"
}
```

# Actor output Schema

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

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("magnova/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("magnova/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 '{}' |
apify call magnova/uspto-trademark-search --silent --output-dataset

```

## MCP server setup

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