# USPTO Trademarks Search, Status and Watch (`automatic/uspto-trademarks-scraper`) Actor

Search US trademarks, retrieve status and prosecution events, and watch new filings or publications. Text matching only; no legal clearance or similarity scoring.

- **URL**: https://apify.com/automatic/uspto-trademarks-scraper.md
- **Developed by:** [Philip Kirkbride](https://apify.com/automatic) (community)
- **Categories:** Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 rows

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 Trademarks Search, Status and Watch

Search US trademark applications and registrations from the USPTO, look up the
status and prosecution history of specific marks, and watch for new filings or
publications that match your terms, owners or classes. Each row carries the
word mark, owners, status, live/dead flag, filing, publication and
registration dates, international classes, goods and services, attorney and a
link to the official TSDR case page. No account or API key is needed.

Built for brand-protection teams, trademark attorneys and paralegals, and
companies that sell trademark services and need fresh filings as leads.

### What you can do with it

- **Watch for conflicting filings.** Schedule a named watch on your brand
  terms and classes and get only the new filings and publications since the
  last run.
- **Catch marks published for opposition.** A watch matches publication dates
  too, so marks entering the opposition window show up.
- **Check a portfolio's status.** Look up serial or registration numbers and
  get the current status, status date, classes and dated prosecution events.
- **Research a competitor.** Search by owner name to list every mark a company
  has filed, live or dead.
- **Generate leads.** Export new applications in a class with their owner and
  attorney of record for outreach.

This Actor matches text and class filters. It does not provide similarity
scoring, legal clearance, legal advice, or trademark infringement detection.
It does not send email or other notifications; schedule watch runs and
consume their dataset rows for alerts.

### Quick start

1. Open the Actor in Apify Console. The form is prefilled with a search for
   `ORCHARD`, 10 results.
2. Change the terms, or add owners, classes, status or filing dates.
3. Click **Start**, then download the dataset as JSON, CSV or Excel.

An empty input (`{}`) returns up to 10 marks containing ORCHARD.

### Input

| Name | Type | Default | What it does |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search`, `status` (look up numbers) or `watch` (new filings and publications). |
| `terms` | array | `ORCHARD` for an unfiltered search | Word mark text to match. |
| `wordMatch` | string | `contains` | `exact` (whole mark) or `contains` (substring), case insensitive. |
| `owners` | array | empty | Owner name phrases. |
| `internationalClasses` | array | empty | Nice classes as three-digit strings, `001` to `045`. |
| `status` | string | `all` | `all`, `live` or `dead`. |
| `filingDateFrom`, `filingDateTo` | string | empty | Inclusive filing-date bounds, `YYYY-MM-DD`. |
| `since` | string | empty | Watch mode: first filing or publication date to match, `YYYY-MM-DD`. |
| `watchName` | string | empty | Watch mode: a name that remembers where the last run stopped. |
| `serialNumbers` | array | empty | Status mode: eight-digit serial numbers. |
| `registrationNumbers` | array | empty | Status mode: five- to eight-digit registration numbers. |
| `maxItems` | integer | `10` | Maximum rows, 1 to 10,000. |

Each list accepts up to 50 values. Unknown input fields stop the run with a
message naming them.

### Modes and examples

Search:

```json
{"mode":"search","terms":["ORCHARD"],"wordMatch":"contains","maxItems":10}
```

Word matching is case insensitive: `exact` matches the whole mark; `contains` matches a literal substring. Owner names use phrase matching, including the source's punctuation and word normalization. Values within each list are alternatives; different fields combine as AND filters. `internationalClasses` accepts three-digit strings `001`–`045`. `status` is `all`, `live` or `dead`. `filingDateFrom` and `filingDateTo` are inclusive `YYYY-MM-DD` bounds. `maxItems` is 1–10,000. Without explicit terms, ORCHARD is used only for a search with no owner or class filter.

```json
{"mode":"status","serialNumbers":["78787878"],"maxItems":10}
```

Alternatively use `registrationNumbers`. Clear search filters when selecting status mode. Each number returns one status row, including classes, goods/services, attorney and dated prosecution events when supplied. Unavailable status details are reported as failed targets. This actor returns event text, without downloading document files.

```json
{"mode":"watch","terms":["ORCHARD"],"internationalClasses":["030"],"since":"2026-01-01","watchName":"orchard-class030","maxItems":1000}
```

A watch matches a filing **or** publication on or after `since`. For later runs, omit `since` to resume the same named watch. An explicit `since` replays that range. `watchName` accepts 1–80 letters, digits, underscores or hyphens. State is stored in the named `uspto-trademark-watches` key-value store under that name. Use distinct names for distinct filters and run a given watch sequentially. Without a name, watch mode is a date-filtered one-off export.

A complete run saves the newest matched event date and remembers the marks already delivered on that date. Truncated, interrupted or failed scans retain their checkpoint, so re-runs can repeat rows. Deduplicate by serial number and matched event date. Raising `maxItems` or narrowing the filters may be necessary to finish a watch. Late indexing of older filings/publications can fall behind a saved date; periodically replay an earlier `since` when completeness matters. Checkpoints are not a complete historical audit or a guarantee against missed changes. Status-only changes to existing marks are not watched.

### Output example

Rows use `rowType` values `searchResult`, `status` or `watchHit`. Common fields include serial/registration numbers, word mark, owners, status, live flag, filing/publication/registration dates, international classes, goods/services, attorney and a canonical TSDR `sourceUrl`. Numbers that serve as identifiers remain strings to preserve leading zeros. Search rows have null `statusDate` and empty detailed `classes`/`prosecutionEvents`; status rows populate them when available. Watch hits include `matchReasons`. Dates are ISO 8601 calendar dates; missing source fields are null or empty arrays.

```json
{
  "rowType": "searchResult",
  "serialNumber": "50012306",
  "registrationNumber": null,
  "wordMark": "HILLWOOD ORCHARDS WHERE HILLS NURTURE, FLAVOR THRIVES",
  "owners": [
    "PRODUCTORA INTERNACIONAL DE BEBIDAS, S.A. DE C.V. (CORPORATION; Mexico)"
  ],
  "status": "NEW APPLICATION - ASSIGNED TO EXAMINER",
  "statusDate": null,
  "live": true,
  "filingDate": "2026-07-24",
  "publicationDate": null,
  "registrationDate": null,
  "internationalClasses": [
    "029"
  ],
  "goodsAndServices": [
    "IC 029: Snack mix consisting primarily of processed nuts, and also including dried fruit, processed seeds and chocolate."
  ],
  "classes": [],
  "attorney": "BRUCE  MARGULIES",
  "prosecutionEvents": [],
  "sourceUrl": "https://tsdr.uspto.gov/#caseNumber=50012306&caseSearchType=US_APPLICATION&caseType=DEFAULT&searchType=statusSearch",
  "matchReasons": []
}
```

This example includes the complete common field set.

### Limits

Each search is limited to the source's first 10,000 results, ordered by serial number. The actor reports truncation explicitly. Date/class filters can narrow a search. Source data and indexing can lag official events. A row is a source snapshot, not a legal determination.

Rows save as pages finish. A run with saved rows succeeds and names failed or unfinished targets in its status. An empty result succeeds; an unavailable source with zero rows fails. Named watches do not advance on partial results. No account or API key is required.

### Pricing

**$0.004 per row** plus **$0.005 per run start**. Starts are counted per GB of memory; a default 512 MB run is one start. See the Pricing tab for current terms.

Worked costs: the 10-row default search is about **$0.045**; a status check of 25 marks about **$0.105**; a daily watch that finds 5 new marks costs about **$0.025** a day; 1,000 rows cost about **$4.01**.

### FAQ

**How fresh is the data?** Every run queries the USPTO live. USPTO indexing can lag official events.

**Can I monitor only new marks?** Yes, that is watch mode with a `watchName`: each run returns the matching filings and publications since the previous complete run.

**Does it download documents or images?** No. Status rows include the prosecution event text and a link to the TSDR case page; no files or mark images are downloaded.

**Which export formats are available?** JSON, CSV, Excel, XML and the other dataset formats Apify offers, or read the dataset from your own code with the Apify API.

### Tips

Use distinct watch names for distinct filters. If completeness matters, periodically replay an earlier `since` date to account for late source indexing, and deduplicate repeated rows.

# Actor input Schema

## `mode` (type: `string`):

Search marks, retrieve status by number, or watch new filings/publications.

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

Word mark text to match. Alternatives within this list; combined with owner/class filters. Defaults to ORCHARD only for an unfiltered search.

## `wordMatch` (type: `string`):

Exact whole word mark or literal substring (case insensitive). Applies to terms only.

## `owners` (type: `array`):

Owner name phrases, matched by the source phrase analyzer. Alternatives within this list.

## `internationalClasses` (type: `array`):

Three-digit Nice classes 001 through 045. Alternatives within this list.

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

Filter search/watch marks by current live/dead flag.

## `filingDateFrom` (type: `string`):

Inclusive filing date lower bound, YYYY-MM-DD; search/watch only.

## `filingDateTo` (type: `string`):

Inclusive filing date upper bound, YYYY-MM-DD; search/watch only.

## `since` (type: `string`):

Inclusive filing or publication date, YYYY-MM-DD. Required for a new watch. Explicit since replays that date range.

## `watchName` (type: `string`):

Persistent watch name: 1–80 letters, digits, underscores or hyphens. Uses the named uspto-trademark-watches store. Filters cannot change under an existing name.

## `serialNumbers` (type: `array`):

Eight-digit application serial numbers; status mode only.

## `registrationNumbers` (type: `array`):

Five to eight digits; status mode resolves each registration to a serial number.

## `maxItems` (type: `integer`):

Maximum delivered rows, 1–10000. A truncated watch does not advance its checkpoint. Status mode uses input target order.

## Actor input object example

```json
{
  "mode": "search",
  "terms": [
    "ORCHARD"
  ],
  "wordMatch": "contains",
  "status": "all",
  "maxItems": 10
}
```

# 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 = {
    "terms": [
        "ORCHARD"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automatic/uspto-trademarks-scraper").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": ["ORCHARD"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automatic/uspto-trademarks-scraper").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": [
    "ORCHARD"
  ],
  "maxItems": 10
}' |
apify call automatic/uspto-trademarks-scraper --silent --output-dataset

```

## MCP server setup

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

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/DIoy4GuJzARvVkhke/builds/A0SDGdjbyqj6bu8iJ/openapi.json