# USPTO Trademark Scraper: Search US Trademarks (TMview) (`dltik/uspto-trademarks-scraper`) Actor

Search US (USPTO) trademarks by brand name, owner, status, Nice class, dates. Get goods & services, application/registration dates, owner, mark image. AI brand-clearance + owner→company. No API key. $0.01/result.

- **URL**: https://apify.com/dltik/uspto-trademarks-scraper.md
- **Developed by:** [Walid](https://apify.com/dltik) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.00005 / actor start

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## USPTO Trademark Scraper: Search US Trademarks

**⭐ Bookmark this actor** — the Apify Store ranks actors by bookmarks, so it's the single strongest signal to keep this USPTO Trademark Scraper visible and maintained.

Search **US trademarks (USPTO)** by brand name, owner, status, Nice class or filing date and get clean, structured JSON: mark name, type, serial/registration number, status, owner, Nice classes, goods & services, filing/registration/expiration dates and the mark image — plus optional **AI brand-clearance** (likelihood-of-confusion) and **owner → company** resolution. No API key, no login: powered by the free official **TMview** search backend (the USPTO is one of its data sources).

### What this USPTO Trademark Scraper does

Trademark searching on the official USPTO tools is slow, paginated and hard to automate. This scraper turns any USPTO trademark search into an API you can call at scale and export to JSON, CSV or Excel:

- **Search US trademarks** by keyword/brand name (`query`), with filters for status, Nice class, mark type and application-date window.
- **Full detail on demand** — registration & expiration dates, opposition window, complete goods & services per Nice class, owner address, representatives and renewal history.
- **Brand-owner intelligence** — resolve each mark's owner to a real company record (portfolio mapping, lead-gen, IP due diligence).
- **AI brand-clearance** — score each existing mark against a proposed brand for likelihood of confusion (semantic + goods overlap), the way an examiner would triage it.
- **Trademark watch** — incremental mode emits only new/updated marks on recurring runs, so a daily/weekly schedule becomes a cheap competitor-filing monitor.

### Who uses it

- **Trademark & IP attorneys** running clearance and watch searches at volume.
- **Brand-protection / monitoring teams** tracking new USPTO filings in their classes.
- **Founders & agencies** clearing a new brand name before launch.
- **Data teams** building brand, owner or competitive-intelligence datasets.

### Input

Minimal input is a single `query`. Example:

```json
{
  "query": "tesla",
  "statuses": ["Registered"],
  "niceClasses": ["9", "12"],
  "maxResults": 50,
  "enrichDetails": true
}
```

| Field | Type | Description |
|---|---|---|
| `query` | string | Brand name or keyword to search (required). |
| `offices` | array | IP office codes. Defaults to `["US"]` (USPTO). Add e.g. `["US","EM"]` to include EUIPO. |
| `statuses` | array | Filter by status: `Registered`, `Filed`, `Expired`, … |
| `niceClasses` | array | Nice classes 1–45 as strings, e.g. `["9","42"]`. |
| `tmTypes` | array | `Word`, `Figurative`, `Combined`, `3-D`, `Sound`, … |
| `applicationDateFrom` / `applicationDateTo` | string | Filing-date window (`YYYY-MM-DD`). |
| `enrichDetails` | bool | Fetch full detail per mark (dates, goods & services, owner address, renewals). |
| `enrichApplicant` | bool | Resolve the owner to a company record. |
| `referenceMark` + `analyzeClearance` | string + bool | AI likelihood-of-confusion clearance vs a proposed brand. |
| `incrementalMode` | bool | Watch mode — only new/updated marks on recurring runs. |
| `maxResults` | int | 1–5000. |

### Output

One JSON record per trademark, for example:

```json
{
  "application_number": "85123456",
  "mark_name": "TESLA",
  "mark_type": "Word",
  "office_code": "US",
  "status": "Registered",
  "lifecycle_stage": "registered",
  "applicant_name": "Tesla, Inc.",
  "nice_classes": [9, 12],
  "application_date": "2010-09-03",
  "registration_date": "2011-08-16",
  "days_until_expiry": 1723,
  "tmview_url": "https://www.tmdn.org/tmview/#/tmview/detail/US..."
}
```

### Pricing

Pay-per-event, so you only pay for what you pull:

| Event | Price | What you get |
|---|---|---|
| `trademark-result` | **$0.01** | Every mark: identity, status, Nice classes, owner, dates + free derived fields (lifecycle, days-to-expiry, clearance score vs a reference mark). |
| `trademark-detail` | +$0.01 | Opt-in full detail per mark (goods & services, registration/expiry/opposition dates, owner address, renewals). |
| `applicant-enriched` | +$0.005 | Opt-in owner → company record resolution. |
| `clearance-analyzed` | +$0.02 | Opt-in AI likelihood-of-confusion per mark (paid Apify plans). |

### FAQ

**Do I need a USPTO or TMview API key?** No. The actor uses the free public TMview search backend — no key, no login, no quota to manage.

**Is this official USPTO data?** The records come from TMview, the EU IP Office's global search network, which ingests USPTO's trademark register as one of its 70+ sources. It's the same data you'd find on the USPTO search, exposed as clean JSON.

**Can I also search other countries?** Yes — set `offices` (e.g. `["US","EM","FR"]`). Leave it unset to search USPTO only.

**Can I monitor new filings?** Yes. Turn on `incrementalMode` and schedule the actor — you'll get only the new/updated marks each run.

**Is the AI clearance legal advice?** No. It's a screening/triage signal to prioritize which marks a professional should review.

# Actor input Schema

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

Free-text search on trademark NAME. Examples: 'apple', 'nike', 'tesla', 'coca cola'. Provide this and/or 'applicantName' — at least one is required.

## `applicantName` (type: `array`):

Search by the APPLICANT / owner name — returns every trademark owned by that entity. Examples: \['NIKE, INC.'], \['APPLE INC'], \['MICROSOFT']. Matches the owner-name text (also catches historical variants). Multiple names = OR. Can be combined with 'query' (mark name) to AND. Provide this and/or 'query'.

## `offices` (type: `array`):

Two-letter IP office codes. Defaults to \['US'] = USPTO. Add others to widen the search: 'EM' = EUIPO, 'FR' = INPI France, 'DE' = DPMA Germany, 'WO' = WIPO Madrid, 'JP' = JPO Japan. Multi-value supported.

## `statuses` (type: `array`):

Filter by status. Common values: 'Registered', 'Filed', 'Expired', 'Application published', 'Application opposed', 'Application refused'. Leave empty for all statuses.

## `niceClasses` (type: `array`):

Nice classification numbers (1-45) — international trademark goods/services categories. Provide as strings: '9' = electronics/software, '25' = clothing, '35' = advertising, '41' = education, '42' = scientific/IT services. Multi-value supported.

## `tmTypes` (type: `array`):

Filter by mark type. Common values: 'Word', 'Figurative', 'Combined', '3-D', 'Sound', 'Colour', 'Hologram', 'Motion'. Leave empty for all types.

## `applicationDateFrom` (type: `string`):

Filter by application date (start). Format: YYYY-MM-DD. Example: '2020-01-01'. Requires applicationDateTo to be set as well.

## `applicationDateTo` (type: `string`):

Filter by application date (end). Format: YYYY-MM-DD. Example: '2026-12-31'. Requires applicationDateFrom to be set as well.

## `enrichDetails` (type: `boolean`):

When ON, fetches the full TMview detail record for EACH result: registration & expiration dates, opposition period start/end, complete goods & services descriptions per Nice class, detailed applicant info (address, nationality), legal representatives, and renewal history. Detail requests run concurrently. Adds one request per result and is billed separately as a 'trademark-detail' event. Leave OFF for fast, cheap name/status/Nice-class search.

## `enrichApplicant` (type: `boolean`):

When ON, resolves each mark's applicant to a real company. French applicants are matched live to their SIREN + size + sector + active/ceased status via the official register (same source as our pappers-sirene-scraper); applicants from 30+ other countries get a pointer to the matching national company-registry actor. Turns trademark data into brand-owner intelligence (lead-gen, competitive mapping, IP due diligence). Billed as 'applicant-enriched' only for applicants successfully resolved to a company record. Best combined with enrichDetails (which provides the applicant's country).

## `referenceMark` (type: `string`):

The proposed brand name you want to CLEAR. When set, every result is scored against it for free: Jaro-Winkler name similarity, phonetic match (Metaphone/Soundex) and Nice-class overlap → a 0-100 computed\_conflict\_score with a band (high/medium/low/none), written into each record's 'clearance' object. Leave empty to skip clearance scoring. Defaults to 'query' when analyzeClearance is ON.

## `referenceNiceClasses` (type: `array`):

The Nice classes (1-45) your proposed mark would be used in. Sharpens the clearance conflict score (a name clash only matters where the goods/services overlap). Provide as strings, e.g. \['9','42']. Optional.

## `analyzeClearance` (type: `boolean`):

When ON, an AI model scores each existing mark against your referenceMark for likelihood of confusion the way an EU examiner would: semantic\_similarity (meaning, not just spelling — catches translations/synonyms), goods\_conflict (overlap of goods & services), an overall likelihood\_of\_confusion 0-100, a verdict (clear/caution/high\_risk), a recommended\_action and one-line reasoning. This is the enterprise brand-clearance feature — screening triage, not legal advice. Billed as 'clearance-analyzed' per mark scored. Requires a paid Apify plan and the account OpenRouter key. Best with enrichDetails ON (feeds the goods & services text to the model).

## `referenceGoods` (type: `string`):

Optional free-text description of the goods/services your proposed mark will cover (e.g. 'mobile software for fitness tracking'). Gives the AI clearance model the context to judge goods conflict. Only used when analyzeClearance is ON.

## `incrementalMode` (type: `boolean`):

When ON, remembers every trademark seen on the previous run (per stateKey) and, on the next run, tags each mark NEW / UPDATED / UNCHANGED. By default only NEW and UPDATED marks are emitted and billed — so scheduling this daily/weekly becomes a trademark-watch that surfaces competitor filings and status changes cheaply. Combine with a schedule for brand monitoring.

## `includeUnchanged` (type: `boolean`):

When incrementalMode is ON, also emit (and bill) marks that did not change since the last run. Leave OFF to receive only the delta.

## `includeExpired` (type: `boolean`):

When incrementalMode is ON, also emit lightweight EXPIRED markers for marks that were present last run but dropped off this run. These markers are metadata and are NOT billed.

## `stateKey` (type: `string`):

Namespace for the incrementalMode baseline, so several saved watches (different queries) keep separate histories under one actor. Any short string, e.g. 'competitor-x' or 'class9-watch'. Defaults to 'default'.

## `detailConcurrency` (type: `integer`):

Number of parallel TMview detail requests when enrichDetails is ON (1-8). Higher finishes large enriched runs faster; the default 4 stays comfortably under TMview's soft rate-limit.

## `pageSize` (type: `integer`):

Results per TMview page. Default 30 matches the official TMview UI. Higher reduces request count for large maxResults.

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

Maximum trademarks to return. Start with 30 to validate filters, scale up once happy. Billing is per result returned.

## `proxyConfig` (type: `object`):

Apify datacenter proxy is enabled by default — TMview blocks plain cloud IPs at the network edge. You can switch to residential if you scrape at very high frequency.

## Actor input object example

```json
{
  "applicantName": [],
  "offices": [
    "US"
  ],
  "statuses": [],
  "niceClasses": [],
  "tmTypes": [],
  "enrichDetails": false,
  "enrichApplicant": false,
  "referenceNiceClasses": [],
  "analyzeClearance": false,
  "incrementalMode": false,
  "includeUnchanged": false,
  "includeExpired": false,
  "detailConcurrency": 4,
  "pageSize": 30,
  "maxResults": 30,
  "proxyConfig": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

The scraped trademark records.

# 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("dltik/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 = {}

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

```

## MCP server setup

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