# USPTO Trademark Scraper (`fetch_cat/uspto-trademarks-scraper`) Actor

Export public USPTO trademark applications by mark, owner, identifiers, class, dates, and status for monitoring and due diligence.

- **URL**: https://apify.com/fetch\_cat/uspto-trademarks-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 trademark records

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/platform/actors/running/actors-in-store#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

This USPTO trademark scraper searches `tmsearch.uspto.gov` and exports public United States Patent and Trademark Office application records by wordmark, owner, serial number, registration number, international class, filing date, and live/dead status.

### Who is it for?

US intellectual-property attorneys, brand-protection teams, ecommerce sellers, and compliance analysts can use this Actor for trademark clearance research, brand-watch lists, owner portfolio reviews, ecommerce due diligence, and compliance analysis. It accepts bulk inputs, paginates results, deduplicates applications by serial number, and preserves which query found each record.

### Search USPTO trademark application data with a small input

```json
{
  "searchTerms": ["APPLE"],
  "status": "live",
  "maxItems": 25
}
```

### Example output

```json
{
  "serialNumber": "78787878",
  "registrationNumber": "3457989",
  "wordmark": "APPLE",
  "status": "LIVE",
  "alive": true,
  "filingDate": "2006-09-20",
  "registrationDate": "2008-07-01",
  "cancellationDate": null,
  "abandonmentDate": null,
  "publicationDate": "2008-04-15",
  "priorityDate": null,
  "ownerNames": ["Apple Inc."],
  "ownerFullText": "Apple Inc.",
  "ownerType": "CORPORATION",
  "attorney": "Attorney of record",
  "internationalClasses": ["009"],
  "usClasses": ["021", "023", "026", "036", "038"],
  "coordinatedClasses": ["009"],
  "goodsAndServices": ["Computers; computer hardware..."],
  "markType": "TRADEMARK",
  "drawingCode": "4",
  "markDescription": null,
  "designCodeDescriptions": [],
  "disclaimer": null,
  "translation": null,
  "currentBasis": ["1A"],
  "originalBasis": ["1B"],
  "registrationType": ["PRINCIPAL"],
  "trademarkUrl": "https://tsdr.uspto.gov/#caseNumber=78787878&caseSearchType=US_APPLICATION&caseType=DEFAULT&searchType=statusSearch",
  "sourceQuery": "term:APPLE",
  "scrapedAt": "2026-08-06T15:00:00.000Z"
}
```

### USPTO trademark scraper output

Export structured trademark application data for analysis, monitoring, and due diligence.

| Field | Description |
|---|---|
| `serialNumber` | Stable USPTO application serial number |
| `registrationNumber` | Registration number when registered |
| `wordmark` | Text of the mark |
| `status`, `alive` | Normalized LIVE/DEAD status and source flag |
| `filingDate`, `registrationDate` | Application and registration dates |
| `cancellationDate`, `abandonmentDate` | End-status dates when present |
| `publicationDate`, `priorityDate` | Opposition publication and priority dates |
| `ownerNames`, `ownerFullText`, `ownerType` | Public owner/applicant data |
| `attorney` | Attorney of record when supplied |
| `internationalClasses`, `usClasses`, `coordinatedClasses` | Trademark classifications |
| `goodsAndServices` | Public goods/services descriptions |
| `markType`, `drawingCode`, `markDescription` | Mark metadata |
| `designCodeDescriptions`, `disclaimer`, `translation` | Design and text details |
| `currentBasis`, `originalBasis`, `registrationType` | Filing and registration basis data |
| `trademarkUrl` | Direct USPTO case-status link |
| `sourceQuery` | Input mode and value that found the record |
| `scrapedAt` | UTC extraction timestamp |

### Input settings

| Key | Type | What it does |
|---|---|---|
| `searchTerms` | string\[] | Wordmarks or keywords |
| `owners` | string\[] | Owner/applicant names |
| `serialNumbers` | string\[] | Exact eight-digit application IDs |
| `registrationNumbers` | string\[] | Exact registration IDs |
| `internationalClasses` | string\[] | Nice Classification numbers |
| `status` | `all`, `live`, `dead` | Status filter; default `all` |
| `filedAfter` | date | Earliest filing date |
| `filedBefore` | date | Latest filing date |
| `maxItems` | integer | Maximum unique records across all queries (1–5,000) |

Provide at least one of `searchTerms`, `owners`, `serialNumbers`, or `registrationNumbers`.

### Input recipes

**Exact serial lookup**

```json
{"serialNumbers":["78787878"],"maxItems":1}
```

**Owner and class portfolio search**

```json
{"owners":["Apple Inc."],"internationalClasses":["9"],"status":"live","maxItems":25}
```

**Mixed brand watchlist**

```json
{"searchTerms":["ACME","EXAMPLE"],"filedAfter":"2025-01-01","maxItems":100}
```

### Pricing

The Actor uses pay-per-event pricing: one small **Start** charge per run plus one **Trademark record** event per dataset item. See the live [Pricing tab](https://apify.com/fetch_cat/uspto-trademarks-scraper/pricing) for current rates and volume discounts. Failed requests and duplicate records are not charged as results.

### Tips and limits

- Start with 25–100 records, then increase `maxItems` after confirming the query.
- Use exact serial numbers for deterministic case lookup.
- Owner names follow USPTO public text and may include historical naming variations.
- Optional legal/mark fields can be empty because older and pending applications differ.
- USPTO can throttle or change its public service. The Actor retries temporary server failures but reports challenge or malformed responses instead of returning misleading empty success.
- This Actor exports public search records only. It does not file applications, access private correspondence, or provide legal advice.

### API usage

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~uspto-trademarks-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms":["APPLE"],"status":"live","maxItems":25}'
```

#### JavaScript (ApifyClient)

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/uspto-trademarks-scraper').call({
  searchTerms: ['APPLE'], status: 'live', maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Python (ApifyClient)

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/uspto-trademarks-scraper').call(run_input={
    'searchTerms': ['APPLE'], 'status': 'live', 'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

Use the [Apify API](https://docs.apify.com/api/v2) to download the default dataset as JSON, CSV, Excel, XML, or RSS.

### Use with AI agents and MCP

Connect through [Apify MCP](https://mcp.apify.com/?tools=fetch_cat/uspto-trademarks-scraper) and ask an agent to search public USPTO records, compare owners/classes, or prepare a brand-watch dataset. Keep result limits bounded for interactive workflows.

### FAQ

#### What data can I export with trademark scraper?

You can export the 31 documented fields above, including IDs, wordmarks, status, owners, attorneys, classifications, goods/services, dates, mark metadata, USPTO links, and provenance.

#### Can I run USPTO Trademarks Scraper through an API, schedule, or MCP client?

Yes. Use the Apify API example above, create a Schedule in Apify Console, or connect the Actor through Apify MCP.

#### How much does it cost to use USPTO Trademarks Scraper?

It charges one small Start event and one Trademark record event per saved result. See the live Pricing tab for current tier rates and discounts.

#### Does this include every USPTO document?

No. It returns structured public trademark search records. Binary prosecution documents and account-only actions are outside this Actor.

#### Why is an optional field empty?

USPTO records vary by application age and prosecution state. The Actor preserves nulls and empty arrays instead of guessing.

#### Can I search several brands at once?

Yes. Add multiple values to `searchTerms`; duplicate serial numbers are saved once.

#### Is this legal advice?

No. The Actor provides public registry data for research. Consult a qualified trademark professional for legal conclusions.

### Related Actors

- [SEC Filings Scraper](https://apify.com/fetch_cat/sec-filings-scraper) for US public-company filing research
- [Google Patents Scraper](https://apify.com/fetch_cat/google-patents-scraper) for patent prior-art workflows

### Support

Open an issue from the Actor's Apify page with the input, run URL, expected result, and affected serial number or query. Do not include confidential credentials or legal correspondence.

# Actor input Schema

## `searchTerms` (type: `array`):

Wordmarks or keywords to find.

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

Owner or applicant names.

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

Exact 8-digit USPTO application serial numbers.

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

Exact USPTO registration numbers.

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

Nice Classification numbers, such as 9, 25, or 35.

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

Return live marks, dead marks, or both.

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

Earliest filing date (YYYY-MM-DD).

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

Latest filing date (YYYY-MM-DD).

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

Maximum unique trademark records to save across all searches.

## Actor input object example

```json
{
  "searchTerms": [
    "APPLE"
  ],
  "status": "all",
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

USPTO trademark application 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 = {
    "searchTerms": [
        "APPLE"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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 = {
    "searchTerms": ["APPLE"],
    "maxItems": 20,
}

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

```

## MCP server setup

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