USPTO Trademark Scraper

Returns: one row per trademark with markText, serialNumber, registrationNumber, ownerName, status, classes, filingDate, firstUseDate, goodsAndServices. Input: {"searchTerms": ["nike"], "status": "live", "internationalClasses": [25], "maxItems": 20} Best for: brand clearance checks, competitor trademark monitoring, attorney and owner lead lists.

{"id": "99905286", "markText": "NIKE FREE IQ", "ownerName": "Nike, Inc. (CORPORATION; Oregon, USA)", "status": "NEW APPLICATION - RECORD INITIALIZED NOT ASSIGNED TO EXAMINER", "isLive": true, "classes": ["025"], "filingDate": "2026-06-25", "filingBasis": ["1b"]}

What does USPTO Trademark Scraper do?

USPTO Trademark Scraper turns the public United States Patent and Trademark Office trademark search into structured data. You give it one or more mark texts, serial numbers, registration numbers or an owner name, optionally narrow the results by status, international class and dates, and it returns one clean record per trademark application or registration. Each record has the mark text, serial and registration number, owner, status, classes, goods and services, filing and registration dates and a link back to the USPTO case page.

The Actor reads the same JSON search service that the USPTO trademark search website uses in your browser. It does not log in, it does not need an API key and it does not solve CAPTCHAs. It works without a proxy, makes about one or two requests per second and retries politely if the service answers with a temporary error.

Typical uses include clearance searches before you file a new mark, monitoring what a competitor has filed, building a list of all live marks in a class, checking who owns a registration, and feeding trademark data into a spreadsheet, a database or an AI agent. The Actor is an independent tool and is not affiliated with or endorsed by the USPTO.

Because every search returns plain JSON, you can export the dataset as JSON, CSV, Excel, XML or HTML from the Apify Console, or fetch it through the API.

What data can you get?

Every record contains the fields below. Fields that the USPTO does not publish for a given mark (for example the registration number of a pending application) are left out of that record instead of being filled with placeholders.

Field	Type	Description
id	string	Stable unique id, equal to the serial number
sourceUrl	string	TSDR case status link for the application
markText	string	Wordmark text; empty for design-only marks
serialNumber	string	USPTO application serial number
registrationNumber	string	Registration number; empty for pending applications
ownerName	string	Owner name with entity type and state, as published
ownerCity	string	First published city when the USPTO lists multiple owner locations
ownerState	string	First published state, postal code and country when multiple locations appear
attorney	string	Attorney of record
status	string	USPTO status description, such as REGISTERED
statusCode	number	Numeric USPTO status code
isLive	boolean	True while the application or registration is live
classes	array of strings	International (Nice) classes, always three digits such as 025
goodsAndServices	array of strings	Goods and services text, one entry per class
filingDate	string	Filing date as YYYY-MM-DD
registrationDate	string	Registration date as YYYY-MM-DD
markType	array of strings	Mark type labels such as TRADEMARK
cancelDate	string	Cancellation date when the mark was cancelled
ownerEntityType	string	Legal entity type of the owner
ownerCitizenship	string	State or country of the owner entity
ownerAddress	array of strings	Full owner text with role, entity and street address, as published
firstUseDate	string	Date of first use anywhere
firstUseInCommerceDate	string	Date of first use in commerce
publicationDate	string	Date published for opposition
abandonDate	string	Date the application was abandoned
renewalDate	string	Latest renewal date
filingBasis	array of strings	Current filing basis codes such as 1a (use) or 1b (intent to use)
registrationType	array of strings	Register type such as PRINCIPAL or SUPPLEMENTAL
drawingType	string	USPTO drawing code description
disclaimer	string	Disclaimer text of the mark
designCodes	array of strings	Individual design search codes of logo marks; comma-separated USPTO values are split into codes
markDescription	array of strings	Description of the mark drawing
priorRegistrations	array of strings	Prior registration numbers claimed
proceedings	array of strings	TTAB proceeding numbers (oppositions, cancellations) linked to the mark
hasAssignmentRecorded	boolean	True if an ownership assignment is recorded
prosecutionHistory	array	Only with the details option: dated events of the case file
maintenance	object	Only with the details option: renewal and maintenance information
assignments	object	Only with the details option: assignment records

Older records in the USPTO database store classes in a slightly different way (for example 025.) and dates with a time suffix. The Actor normalises both, so classes are always three-digit strings and dates are always plain dates.

What is new

Each record now also carries owner entity type, citizenship and full owner address, first-use dates, publication, abandon and renewal dates, filing basis, registration type, drawing type, disclaimer, design codes, mark description, prior registrations, linked TTAB proceeding numbers and an assignment-recorded flag. Owner entity type and citizenship use the first non-empty published value when the search index supplies multiple values, matching the selection used for owner city and state. Fields the USPTO leaves empty are omitted from the item.

How to use USPTO Trademark Scraper

1. Open the Actor in the Apify Console and go to the Input tab.
2. Enter one or more mark texts, for example nike. A mark text is a phrase match, so nike also finds marks such as NIKE FREE.
3. Optionally set the status, one or more international classes, filing dates or registration dates.
4. Set the maximum number of items you want and press Start.
5. When the run finishes, open the Output tab to view or download the dataset.

You can also look up exact records. Put serial numbers into the serial numbers field or registration numbers into the registration numbers field. You can search by owner alone as well: leave the mark text empty and enter an owner name such as Nike, Inc..

If you combine several mark texts, each one runs as its own search and the results are merged. A trademark that matches more than one search is returned only once.

Large searches

The USPTO search service returns at most 10,000 results for a single query. If a search matches more than that, the Actor logs a warning. To collect everything, split the search into smaller ones, for instance one run per international class or per range of filing dates.

Details option

When you switch on the details option, the Actor makes one extra request per record to the USPTO case status service. This adds the prosecution history, the maintenance information and the assignments to each record. Correspondent e-mail addresses that appear in the case file are removed from the output. Runs with details are slower because of the extra request, so use a smaller item limit.

Input

Field	Type	Description
searchTerms	array of strings	Mark texts to search, phrase match anywhere in the mark
serialNumbers	array of strings	Exact application serial numbers to look up
registrationNumbers	array of strings	Exact registration numbers to look up
ownerName	string	Only marks whose owner name contains this phrase
status	string	all, live or dead. Default all
internationalClasses	array of integers	Classes 1 to 45 that the mark must be filed in
filedFrom, filedTo	string	Filing date range, YYYY-MM-DD
registeredFrom, registeredTo	string	Registration date range, YYYY-MM-DD
includeDetails	boolean	Add prosecution history, maintenance and assignments. Default false
maxItems	integer	Total number of records to return, 1 to 10000. Default 50
proxyConfiguration	object	Apify Proxy settings. Default is no proxy

Example input:

{
  "searchTerms": ["nike"],
  "status": "live",
  "internationalClasses": [25],
  "maxItems": 20
}

The Actor returns exactly the number of records you ask for in maxItems when that many exist, and never more. If the input is invalid, for example a date in the wrong format, the run fails within seconds with a clear message. If a search term matches nothing, the run finishes successfully with zero items and a status message that says what to change (shorter text, fewer filters, digits-only numbers). On a successful run with results the status message is Done: <n> results. followed by a rating request.

Output

Each item in the dataset looks like this. The example is a real record returned by the Actor.

{
  "id": "73361064",
  "sourceUrl": "https://tsdr.uspto.gov/#caseNumber=73361064&caseSearchType=US_APPLICATION&caseType=DEFAULT&searchType=statusSearch",
  "serialNumber": "73361064",
  "markText": "NIKE",
  "registrationNumber": "1237469",
  "ownerName": "Nike, Inc. (CORPORATION; OREGON, USA)",
  "ownerCity": "Beaverton",
  "ownerState": "OREGON 970056453, UNITED STATES",
  "attorney": "Jennifer Martin Reynolds",
  "status": "REGISTERED AND RENEWED",
  "statusCode": 800,
  "isLive": true,
  "classes": ["025"],
  "goodsAndServices": ["IC 025: ATHLETIC AND CASUAL CLOTHING FOR MEN, WOMEN AND CHILDREN-NAMELY, SHIRTS, PANTS, SHORTS, JACKETS, HEADWEAR, and SOCKS."],
  "filingDate": "1982-04-22",
  "registrationDate": "1983-05-10",
  "markType": ["TRADEMARK"]
}

Results are sorted by filing date, newest first. The dataset has an overview view in the Console that shows the most useful columns.

How much does it cost?

The Actor is charged per result: you pay for each trademark record that is added to the dataset, and nothing for records that are not returned. See the Pricing tab of the Actor for the current rate. Because the USPTO service is free and needs no proxy, there are no other costs besides the usual Apify platform usage. Use maxItems to cap what a run can cost.

Use with AI agents (MCP)

You can call this Actor from any AI agent that supports the Model Context Protocol through the Apify MCP server. Use this server URL:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=axiomworks/uspto-trademark-search-scraper"
    }
  }
}

Example prompts for your agent:

• "Find all live trademarks for the mark NIKE in class 25 and list the owner and registration number."
• "Who owns the trademark with serial number 98029846, and what is its current status?"
• "List trademarks containing the word apple that were filed since 2022."

Integrations and API

You can start the Actor from your own code with the Apify API clients or with a plain HTTP request. Replace YOUR_API_TOKEN with your token.

Python:

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("axiomworks/uspto-trademark-search-scraper").call(
    run_input={"searchTerms": ["nike"], "status": "live", "maxItems": 20}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["markText"], item["serialNumber"], item["status"])

JavaScript:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('axiomworks/uspto-trademark-search-scraper').call({
    searchTerms: ['nike'],
    status: 'live',
    maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => process.stdout.write(`${item.markText} ${item.serialNumber}\n`));

cURL:

curl -X POST "https://api.apify.com/v2/acts/axiomworks~uspto-trademark-search-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms": ["nike"], "status": "live", "maxItems": 20}'

You can also connect the dataset to Google Sheets, Make, Zapier, n8n or webhooks through the Apify integrations, and schedule the Actor to run daily to monitor new filings by an owner or in a class.

FAQ

Does it need a proxy? No. The USPTO search works from normal data center addresses. The proxy setting is there in case the service starts blocking your traffic; if you enable it, blocked requests are retried on a fresh proxy session.

Why is registrationNumber missing on some records? Pending applications have not been registered yet, so the USPTO has no registration number for them.

Why is markText missing on some records? Design-only marks, such as a logo without words, have no wordmark text.

Why do I get marks that only contain my search word? Mark text search is a phrase match anywhere in the mark. A search for apple also returns marks such as GREEN APPLE. Filter the results by markText afterwards if you need exact matches.

Why did I get fewer items than maxItems? Fewer marks matched your search and filters. Check the log; it lists the number of matches.

What does the class filter do when I list several classes? Each class you list must be present on the mark.

How fresh is the data? The Actor reads the live USPTO search index, which is updated by the USPTO regularly. The data is as current as the USPTO website.

What happens if the USPTO changes its service? The search service is not an official documented API. If its format changes the Actor may need an update; please report problems through the Issues tab.

Is it legal to scrape USPTO data?

The USPTO publishes trademark records as public information so that anyone can search them. The Actor only reads this public data without logging in and without bypassing any protection, and it keeps its request rate low so that it does not burden the service. The records include owner names, addresses and attorney names exactly as the USPTO publishes them. You are responsible for using the data in line with applicable laws, such as privacy and marketing rules, and with the terms of the source. A trademark search is not legal advice and does not replace a professional clearance search.

Feedback

If something does not work, or you need another field, open an issue on the Actor page in the Apify Store. Please include the run link and the input you used so we can reproduce the problem.