# USPTO Trademark Search — Lookup, Availability & Data (`sian.agency/uspto-trademark-scraper`) Actor

Search and extract USPTO trademark data — keyword search, brand-name availability checks, owner and full-text search, serial-number lookups, class suggestions, and expiring-mark discovery. Seven operations, one clean dataset per run. No API key, no setup.

- **URL**: https://apify.com/sian.agency/uspto-trademark-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Business, Lead generation, Developer tools
- **Stats:** 32 total users, 10 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 — Lookup, Availability & Portfolio Data 🔎

[![Store-SIÁN Agency](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Store-Instagram AI Transcript](https://img.shields.io/badge/Store-Instagram%20AI%20Transcript-E4405F)](https://apify.com/sian.agency/instagram-ai-transcript-extractor?fpr=sian) [![Store-Zillow Agent Scraper](https://img.shields.io/badge/Store-Zillow%20Agent%20Scraper-1F4E79)](https://apify.com/sian.agency/zillow-agent-scraper?fpr=sian) [![Store-Idealista Scraper](https://img.shields.io/badge/Store-Idealista%20Scraper-E60023)](https://apify.com/sian.agency/smart-idealista-scraper?fpr=sian)

#### 🎉 Seven trademark tools in one — search the entire U.S. register, check brand-name availability, and map any owner's portfolio

##### Built for founders clearing brand names, IP paralegals running due diligence, and agencies monitoring trademarks at scale

***

### 📋 Overview

**Looking up a trademark shouldn't mean clicking through a clunky government portal one mark at a time.** This actor turns the U.S. Patent & Trademark Office register into clean, structured data — search thousands of marks, check if a name is free, and export everything to JSON, CSV, or Excel.

### 🔀 Two USPTO actors — which one do you need?

We publish two, and they answer different questions. They share the register; they do not overlap.

| Your question | Use |
|---|---|
| **Is this name free to register?** Availability across Nice classes, class suggestions, an owner's whole portfolio, marks about to expire | **This actor** |
| **What happened to this application, and who is behind it?** Full prosecution timeline, TTAB proceedings, assignments, the prosecuting attorney and correspondent, goods & services exactly as filed | [USPTO Trademark Search & Status Scraper — Dossier & Discovery](https://apify.com/sian.agency/uspto-trademark-search-status-scraper?fpr=sian) |

A common workflow uses both: clear the name here, then pull the file on whatever it collides with using the dossier actor.

**Why professionals choose this actor:**

- ✅ **Seven operations in one**: keyword search, availability check, serial-number details, owner portfolio, full-text search, class suggestions, and expiring marks — no other Apify trademark tool covers them all
- ⚡ **Up to 250 records per keyword** in a single call, with deep pagination for owner and full-text searches
- 🎯 **100% data-source success rate** and sub-second lookups — reliable enough for production monitoring
- 💰 **Pay-per-record pricing** — only pay for the marks you actually receive, with a free tier to test
- 💎 **Unique tools nobody else offers**: instant Nice-class suggestions and date-windowed expiring-mark discovery for renewal lead-gen
- ✨ **Zero setup**: no USPTO account, no API key, no proxy configuration — just pick an operation and run

***

### ✨ Features

- 🔎 **Trademark Search**: find live or all marks by keyword — status, owners, classes, filing & registration dates, and the official logo
- ✅ **Availability Check**: instant "available / taken" verdict for a brand name, broken down across all 45 Nice classes
- 📑 **Trademark Detail**: full record for any serial number — owners, classification, and complete status history
- 🏢 **Owner Search**: pull every mark filed under a company or applicant name — one row per trademark, ready for portfolio analysis
- 🔠 **Full-Text Search**: search inside goods-and-services descriptions, not just mark names
- 🏷️ **Class Suggestion**: get recommended Nice classes for any product or service description before you file
- ⏳ **Expiring Marks**: list marks expiring in any date window — a renewal lead-gen engine for IP attorneys
- 📊 **Clean structured output**: flat camelCase rows, an HTML run report, and one-click CSV/Excel/JSON export

***

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Pick an operation

Choose one of the seven operations from the dropdown (Trademark Search is the default).

#### Step 2: Enter your queries

Add keywords, owner names, serial numbers, or descriptions to the **Queries** list — or a date window for Expiring Marks.

#### Step 3: Run

Start the actor. Results stream into the dataset in seconds, ready to export.

**That's it! In under a minute, you'll have:**

- Clean, structured trademark records
- An availability verdict or a full owner portfolio
- A downloadable dataset (JSON, CSV, Excel) plus an HTML run summary

***

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `operation` | string | **Yes** | One of: `search`, `availability`, `details`, `suggestClass`, `ownerSearch`, `fullText`, `expiring` |
| `queries` | array | Conditional | Keywords, owner names, serial numbers, or descriptions (one per operation). Not used by `expiring` |
| `searchType` | string | No | `active` (live marks) or `all` (incl. dead/abandoned) — Trademark Search only |
| `maxResultsPerQuery` | integer | No | Cap records per keyword (1–250) — Trademark Search only |
| `startDate` | string | Conditional | `YYYY-MM-DD` window start — Expiring Marks only |
| `endDate` | string | Conditional | `YYYY-MM-DD` window end (≤ 7 days from start) — Expiring Marks only |
| `maxPages` | integer | No | Pages to drain for paginated operations (1–50, ~250 records/page) |

**Example — search for a brand:**

```json
{
  "operation": "search",
  "queries": ["apple", "tesla"],
  "searchType": "active",
  "maxResultsPerQuery": 100
}
```

**Example — check if a name is available:**

```json
{
  "operation": "availability",
  "queries": ["zillowmatic", "brandcraft"]
}
```

**Example — map an owner's entire portfolio:**

```json
{
  "operation": "ownerSearch",
  "queries": ["Apple Inc."],
  "maxPages": 5
}
```

***

### 📤 Output

Results are saved to the Apify dataset as flat rows. Filter by `_operation` to split modes. Key fields:

| Field | Type | Description |
|-------|------|-------------|
| `keyword` | string | The trademark wordmark / searched term |
| `serialNumber` | string | USPTO serial number |
| `registrationNumber` | string | USPTO registration number (null for pending) |
| `statusLabel` | string | e.g. "Live/Registered" |
| `filingDate` | string | Application filing date |
| `registrationDate` | string | Registration date |
| `description` | string | Goods & services description |
| `classification` | array | International/US class details |
| `owners` | array | Owner/applicant records |
| `ownerName` | string | Owner name (Owner Search) |
| `available` | string | `yes` / `no` (Availability Check) |
| `availableClasses` | array | Free Nice classes (Availability Check) |
| `classCode` | string | Recommended class (Class Suggestion) |
| `markPageUrl` | string | Direct link to the USPTO TSDR status page |

**Example row:**

```json
{
  "_operation": "search",
  "keyword": "APPLE",
  "serialNumber": "77428980",
  "registrationNumber": "4088195",
  "statusLabel": "Live/Registered",
  "filingDate": "2008-03-24",
  "description": "Computers; computer software ...",
  "owners": [{ "name": "Apple Inc.", "city": "Cupertino", "state": "CA" }],
  "markPageUrl": "https://tsdr.uspto.gov/#caseNumber=77428980&caseType=SERIAL_NO&searchType=statusSearch"
}
```

***

### 💼 Use Cases & Examples

#### 1. Brand Clearance Before Filing

**Founders and brand teams checking whether a name is free before investing in it.**
**Input:** `availability` with your candidate names · **Output:** available/taken verdict + class breakdown · **Use:** avoid filing fees and rebrands on names that are already taken.

#### 2. Trademark Watch & Monitoring

**Agencies and legal teams tracking new filings over time.**
**Input:** scheduled `search` or `ownerSearch` runs · **Output:** fresh marks each run · **Use:** catch competitor filings and potential infringements early.

#### 3. IP Due Diligence

**M\&A and licensing teams validating a target's trademark assets.**
**Input:** `details` with serial numbers · **Output:** full records with owners and status history · **Use:** verify ownership and status before a deal closes.

#### 4. Competitor Portfolio Mapping

**Analysts mapping a company's entire brand footprint.**
**Input:** `ownerSearch` with a company name · **Output:** one row per mark, with owner identity · **Use:** size up a competitor's IP estate in one run.

#### 5. Class Research for New Filings

**Applicants choosing the right Nice classes before filing.**
**Input:** `suggestClass` with a product/service description · **Output:** ranked class recommendations · **Use:** file in the correct classes the first time.

#### 6. Renewal Lead Generation

**Trademark attorneys and brand-protection services sourcing leads.**
**Input:** `expiring` with a date window · **Output:** marks expiring soon · **Use:** reach owners before their marks lapse.

#### 7. Goods & Services Research

**Researchers searching descriptions, not just mark names.**
**Input:** `fullText` with a keyword · **Output:** marks whose descriptions mention your term · **Use:** find marks in a product category regardless of the wordmark.

***

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/uspto-trademark-scraper').call({
  operation: 'search',
  queries: ['apple'],
  searchType: 'active'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/uspto-trademark-scraper').call(
    run_input={'operation': 'availability', 'queries': ['brandcraft']}
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~uspto-trademark-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"operation": "ownerSearch", "queries": ["Apple Inc."], "maxPages": 3}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger**: Schedule (e.g. weekly trademark watch) or webhook
2. **HTTP Request**: Call the actor API with your operation + queries
3. **Process**: Handle the JSON dataset
4. **Action**: Alert on new filings, append to a CRM, or build a report

***

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- Full feature access — every operation, same data quality
- No credit card required
- Perfect for testing a few lookups before scaling

#### PAID Tier (Production Ready)

- Unlimited records and pages per run
- Pay-per-record: only charged for the marks you actually receive
- A fixed, low run-start fee plus a transparent per-record rate

💰 **Cheaper than premium single-purpose trademark actors** — and you get all seven tools in one.

🔗 [View current pricing](https://apify.com/sian.agency/uspto-trademark-scraper?fpr=sian)

***

### ❓ Frequently Asked Questions

**Q: Which operation should I use to check if my brand name is free?**
A: Use **Availability Check** — it returns an instant yes/no plus the list of classes where the name is free or taken.

**Q: How many records can I get per run?**
A: FREE tier is capped to a small sample; PAID is unlimited. Keyword search returns up to 250 records per term; owner and full-text searches paginate further.

**Q: Do I need a USPTO account or API key?**
A: No. The actor is fully zero-config — just pick an operation and run.

**Q: What output formats are available?**
A: JSON, CSV, and Excel — export directly from the Apify dataset.

**Q: How fresh is the data?**
A: It reflects the USPTO register and is updated daily at the source.

**Q: Can I monitor trademarks automatically?**
A: Yes — schedule the actor (e.g. a weekly owner or keyword search) and connect it to N8N, Zapier, or Make for alerts.

***

### 🐛 Troubleshooting

**Owner Search returns no rows**

- Use the exact registered owner name, including suffixes (e.g. `Apple Inc.` not `Apple`). Try variations.

**Expiring Marks returns an error**

- The date window must be 7 days or fewer, and both dates must be `YYYY-MM-DD`.

**Search returns fewer rows than expected**

- Increase `maxResultsPerQuery`, or set `searchType` to `all` to include dead/abandoned marks.

***

### ⚖️ Is it legal to scrape data?

This actor returns U.S. trademark records from the public USPTO register — information the government publishes for exactly this kind of lookup. It does not extract private personal data.

However, you should be aware that results may contain personal data (e.g. an individual applicant's name or address as filed publicly with the USPTO). Personal data is protected by the **GDPR** in the European Union and by other regulations around the world. You should not use personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

***

### 🤝 Support

**Join our active support community**

- For issues or questions, open an issue in the actor's Issues tab
- Check the [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Changelog

This Actor's version history is a separate document: https://apify.com/sian.agency/uspto-trademark-scraper/changelog.md

# Actor input Schema

## `operation` (type: `string`):

🎯 **PICK ONE OPERATION PER RUN.** Each run produces one clean dataset matching the chosen mode.

- **🔎 Trademark Search** — find marks by keyword; up to 250 records per term (status, owners, classes, dates, logo)
- **✅ Availability Check** — instant available / not-available verdict per brand name, with the free & taken class list
- **📑 Trademark Detail** — full record for a known serial number (owners, classification, status history)
- **🏷️ Class Suggestion** — recommended Nice classes for a product/service description
- **🏢 Owner Search** — every mark filed by an owner / applicant name (paginated)
- **🔠 Full-Text Search** — search inside goods-and-services descriptions (paginated)
- **⏳ Expiring Marks** — marks expiring in a date window — lead-gen for renewals (paginated)

💡 **TIP:** To combine operations, run the actor multiple times with different configurations.

## `queries` (type: `array`):

🔢 **The list of values to look up — meaning depends on the operation:**

- **Search / Availability / Full-Text** → brand keywords (e.g. `apple`, `zillowmatic`)
- **Details** → serial numbers (e.g. `99408353`)
- **Owner Search** → owner / applicant names (e.g. `Apple Inc.`)
- **Class Suggestion** → product/service descriptions (e.g. `software development`)

Add as many as you like — each value is processed and saved to the dataset.

⚠️ **Ignored** for the **Expiring Marks** operation (which uses the date window below).

## `searchType` (type: `string`):

🔘 **Applies to Trademark Search.** `active` returns live marks only; `all` includes dead/abandoned marks too.

## `maxResultsPerQuery` (type: `integer`):

🔝 **Applies to Trademark Search.** Cap the number of records returned per keyword (the data source returns up to 250). Lower it to preview results before scaling up.

## `startDate` (type: `string`):

🗓️ **Required for Expiring Marks.** Window start, `YYYY-MM-DD`. The window must span **7 days or fewer**.

## `endDate` (type: `string`):

🗓️ **Required for Expiring Marks.** Window end, `YYYY-MM-DD`. Must be within 7 days of the start date.

## `maxPages` (type: `integer`):

📄 **Applies to paginated operations** (Owner Search, Full-Text Search, Expiring Marks) — ~250 records per page. Single-record operations ignore this.

💡 Start small (1–3 pages) to preview. ⚠️ Hard cap: 50 pages.

## Actor input object example

```json
{
  "operation": "search",
  "queries": [
    "apple"
  ],
  "searchType": "active",
  "maxResultsPerQuery": 250,
  "startDate": "2026-06-01",
  "endDate": "2026-06-07",
  "maxPages": 5
}
```

# Actor output Schema

## `output` (type: `string`):

Trademark records, availability verdicts, or class suggestions — one flat row per upstream item with curated camelCase fields (keyword, serialNumber, registrationNumber, statusLabel, filingDate, owners, classification, …).

## `report` (type: `string`):

HTML report with run status, success/error row counts, success rate, upstream calls, duration, and the inputs used — written even on fatal crash.

# 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 = {
    "queries": [
        "apple"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/uspto-trademark-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 = { "queries": ["apple"] }

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/uspto-trademark-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 '{
  "queries": [
    "apple"
  ]
}' |
apify call sian.agency/uspto-trademark-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sian.agency/uspto-trademark-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/zHNrahao9f6TDu6nO/builds/p6GumjUBQcXsMl4d5/openapi.json