# USPTO Trademark Applications & Status Feed (`thoob/uspto-trademark-feed`) Actor

Clean, flat US trademark records from the official USPTO daily data: word mark, serial and registration number, owner, goods and services, class, status and dates, with a what-changed-since-last-run mode. Billed only per delivered record. No API key needed.

- **URL**: https://apify.com/thoob/uspto-trademark-feed.md
- **Developed by:** [Pono Data](https://apify.com/thoob) (community)
- **Categories:** Developer tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 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 Applications & Status Feed

Clean, flat US trademark records from the official USPTO daily trademark data.
Get one useful row per mark with its word mark, serial and registration number,
owner and address, goods and services, international class, status and dates, and
run a changes-only mode that returns just the marks that moved since your last
run.

You pay only for a delivered trademark record. Filtered-out rows, unchanged rows
in changes mode, and malformed records cost nothing. There is no start fee.

### No API key needed

The USPTO bulk data API requires a key. The actor supplies one, so there is
nothing to sign up for and nothing to paste. Start a run and you get rows.

If you would rather run under your own USPTO account and its own quota, request a
key at https://data.uspto.gov/apikey and paste it into the `apiKey` field. It is
stored as a secret and is never written to the dataset or the log.

### What a record is

One flat row per trademark case file:

- identity: `serialNumber`, `registrationNumber` (null until it registers),
  `isRegistered`
- the mark: `markIdentification` (the word mark), `markDrawingCode`, `markTypes`
  (trademark, service mark, collective, certification)
- status and timeline: `statusCode`, `statusDate`, `filingDate`,
  `registrationDate`, `abandonmentDate`, `publicationDate`, `renewalDate`,
  `transactionDate`
- owner: `ownerName`, `ownerCity`, `ownerState`, `ownerCountry`, plus a full
  `owners` list with street, postcode, nationality and legal entity code for
  marks with more than one owner
- classification: `internationalClasses`, `primaryClass`, and a `classifications`
  list carrying the US classes and the first-use dates per class
- what it covers: `goodsAndServices`, the actual recited goods and services text
- proceedings and maintenance: `oppositionPending`, `cancellationPending`,
  `renewalFiled`, `section8Filed`, `section8Accepted`, `section15Filed`,
  `intentToUse`, `supplementalRegister`, `foreignPriority`, and more
- provenance: `sourceUrl`, `retrievedAt`, `confidence`, `jurisdiction`,
  `dataSource`, and in changes mode `changeType`

Every value appears verbatim in the USPTO record, and `sourceUrl` is that mark's
own public TSDR page, so any row can be checked at the source. Dates are
normalised to ISO (YYYY-MM-DD). USPTO writes an absent date as `00000000` and an
absent registration number as `0000000`; both are reported as null rather than as
a real value. Nothing is guessed.

### Sample output

A real slice of one day's file (abbreviated):

| markIdentification | serialNumber | registrationNumber | statusCode | filingDate | ownerName | ownerState | internationalClasses |
|---|---|---|---|---|---|---|---|
| BTF | 50013146 | | 630 | 2026-07-25 | Bridge to Turkiye | NC | 036 |

A pending application has no registration number. That is reported as null, not
as zero, so you can filter on it.

### Two modes

- **full**: every matching record in the window.
- **changes**: only marks that are new to you, or whose status, registration,
  abandonment, renewal or owner has moved since this account's last run. The
  state is tracked per account, so it is your timeline. The first changes run has
  no baseline, so it returns everything matching once, then tracks deltas.

### Filters

- **lookbackDays**: how many days of USPTO daily files to read, counting back
  from today. USPTO publishes on business days, so 3 typically covers the last
  two or three published files.
- **markContains**: keep only marks whose word mark contains this text.
- **ownerContains**: keep only records where an owner's name contains this text.
  This is the portfolio watch.
- **internationalClasses**: Nice classes, for example 009 for software, 025 for
  clothing, 042 for tech services. A leading zero is optional.
- **ownerStates**: two-letter US state codes.
- **statusCodes**: USPTO status codes, for example 630 for a new application
  awaiting examination or 700 for registered.
- **registeredOnly**, **liveOnly**: drop pending applications, or drop marks
  carrying an abandonment date.
- **maxRecords**: cap on delivered and billed records. Defaults to 1000, because
  one USPTO day holds around 9,500 records. Set 0 for no cap. In changes mode
  nothing is lost to the cap; the rest arrives on a later run and is never billed
  twice.

### What to expect

- USPTO publishes one file per business day, and each holds every application or
  registration that had activity that day. Measured on the 2026-08-01 file: 9,457
  records. A busy day is several times that.
- A daily file is large, 9 MB to 49 MB compressed. The actor streams it rather
  than loading it, so a wide lookback is a matter of time rather than memory, and
  a run that reaches its time limit stops cleanly and delivers what it fetched.
- The raw bulk data is public and free directly from USPTO with a key of your
  own. What this actor sells is the flat typed record, the owner and class and
  goods-and-services extraction out of a large XML document, the filtering, and
  the per-account change feed, so you do not have to download and parse hundreds
  of megabytes of XML to find the handful of marks you care about.

### Source and scope

What this collects: public US federal trademark registry records, covering marks
and the businesses that own them.
Source: the official USPTO Open Data Portal bulk product "Trademark Full Text XML
Data (No Images) - Daily Applications", accessed over the documented API with a
declared identifying User-Agent. No scraping, no access bypass.
Scope: United States federal trademark records. Every row is stamped
`jurisdiction=US`.
Billing: charged only on a delivered trademark record; rejects are free; no start
fee.
Provenance: every row carries its TSDR source URL and the retrieval time.

These are public business records. This is a data tool, not legal advice, and a
trademark record is a public filing rather than an opinion on anyone's rights.

### See also

More clean, pay-only-for-results data tools from Pono Data:

- [USPTO Patent Search & Changes Feed](https://apify.com/thoob/uspto-patent-feed) - US patent records from the USPTO Open Data Portal
- [Federal Contract Opportunities Feed](https://apify.com/thoob/sam-opportunities-feed) - US federal contract opportunities from SAM.gov

Full catalog: https://apify.com/thoob

# Actor input Schema

## `apiKey` (type: `string`):

Optional. The actor supplies a working key, so you can leave this blank. Pass your own to run against your own quota. Stored as a secret; never written to the dataset or logs.

## `lookbackDays` (type: `integer`):

How many days of USPTO daily trademark files to read, counting back from today. USPTO publishes on business days, so a lookback of 3 typically covers the last 2 or 3 published files. Each day holds roughly 9,500 records.

## `markContains` (type: `string`):

Optional. Keep only marks whose word mark contains this text, matched case-insensitively. Leave empty for every mark.

## `ownerContains` (type: `string`):

Optional. Keep only records where an owner's name contains this text, matched case-insensitively. Useful for watching one company's portfolio.

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

Optional. Keep only marks in these Nice international classes (for example 009 for software, 025 for clothing, 042 for tech services). Leave empty for all classes.

## `ownerStates` (type: `array`):

Optional. Keep only marks with an owner in these US states (two-letter postal codes). Leave empty for all.

## `statusCodes` (type: `array`):

Optional. Keep only marks carrying one of these USPTO status codes (for example 630 for a new application awaiting examination, 700 for registered). Leave empty for all statuses.

## `registeredOnly` (type: `boolean`):

Keep only marks that carry a registration number, dropping pending applications.

## `liveOnly` (type: `boolean`):

Drop marks that carry an abandonment date.

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

full returns every matching record in the window. changes returns only marks that are new to you or whose status, registration, abandonment, renewal or owner has moved since your last run.

## `maxRecords` (type: `integer`):

Cap on how many records a run delivers and bills. Defaults to 1000, because a single USPTO day holds around 9,500 records and a busy one holds far more. Set 0 for no cap. In changes mode nothing is lost to the cap: the rest arrives on a later run and is never billed twice. The platform spend cap is honored regardless.

## Actor input object example

```json
{
  "lookbackDays": 3,
  "markContains": "coffee",
  "registeredOnly": false,
  "liveOnly": false,
  "mode": "full",
  "maxRecords": 1000
}
```

# Actor output Schema

## `trademarks` (type: `string`):

One row per trademark record matching your filter.

# 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 = {
    "markContains": "coffee"
};

// Run the Actor and wait for it to finish
const run = await client.actor("thoob/uspto-trademark-feed").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 = { "markContains": "coffee" }

# Run the Actor and wait for it to finish
run = client.actor("thoob/uspto-trademark-feed").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "markContains": "coffee"
}' |
apify call thoob/uspto-trademark-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=thoob/uspto-trademark-feed",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/BFa74bHeelfk80JXg/builds/RrzCeQTLE9nhdfwQ7/openapi.json