# USPTO New Trademark Filings — Leads with Contacts (`foxlabs/uspto-trademark-leads`) Actor

Daily US trademark application leads from USPTO TSDR. Owner name & address, attorney, correspondent email & phone, pro-se flag, classes and goods — for IP law firms, brand protection and filing services. Date presets, polite official-source access, no key required.

- **URL**: https://apify.com/foxlabs/uspto-trademark-leads.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 results

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 New Trademark Filings — Leads with Contacts

**The freshest published US trademark applications, delivered as leads.** Every row carries the owner's name & address, the correspondent **email** and **phone**, attorney details, a **pro-se flag** (self-filed applicants — the classic IP-firm lead), Nice classes and the goods/services text. Straight from USPTO's public TSDR records.

Measured on real output (July 2026, n=60): **contact email 100%** of rows, phone 70%, owner name & address 100%.

### What does this Actor do?

USPTO receives ~1,700-2,000 new trademark applications every business day. This Actor walks the newest applications published in TSDR (the USPTO status system) and turns each into a structured lead:

- **Freshest published filings** *(default)* — always returns the newest applications available at the source, walking back from the publication frontier. Schedule it daily with *Only new since last run* for an exact daily batch.
- **Custom filing-date range** — backfill any window (e.g. all of June) for market research.
- **Serial range / serial list** — fetch specific applications by US serial number.

**Honesty note on freshness:** USPTO publishes newly filed applications to TSDR with a capture delay of roughly **5-10 days after the filing date** (measured July 2026). Every "daily trademark leads" service on the market works from this same publication pipeline — "freshest" here means *the newest data that exists publicly*, and that is exactly what you get.

### Why use it?

- **Pro-se applicants** filed without an attorney: their own contact email is on the public record, and they are the primary audience for trademark attorneys, filing services and brand-protection offers. Roughly a quarter of US applications are pro-se — hundreds of fresh leads per business day.
- **Attorney-represented filings** expose the attorney/correspondent contact — ideal for competitor monitoring, legal-industry analytics and partnership outreach.
- Subscription lead services sell this same public data at **$99-$2,499/month**. Here you pay per result, schedule it yourself, and export JSON/CSV/Excel or pull via API.

### How to use it

1. Click **Try for free** — the default input fetches the freshest published filings.
2. Optionally set **Filer type** to *Pro-se only* for the classic lead feed.
3. For a daily pipeline: **schedule** the Actor daily, enable **Only new since last run**, set Max results to ~2,500.
4. Download results from the **Output** tab or via API.

### Input example

```json
{
    "mode": "new_filings",
    "datePreset": "freshest",
    "filerType": "pro_se_only",
    "maxResults": 300
}
```

### Output example

```json
{
    "serialNumber": "99948009",
    "markText": "THE GYM EVANGELIST",
    "filingDate": "2026-07-18",
    "isProSe": true,
    "contactEmail": "barrett***@gmail.com",
    "correspondentPhone": "1-(586) 277-8434",
    "ownerName": "Takora Barrett",
    "ownerAddress": "Sterling Heights, MICHIGAN UNITED STATES 48313",
    "attorneyName": null,
    "intlClasses": ["041"],
    "status": "New application awaiting assignment to an examining attorney.",
    "tsdrUrl": "https://tsdr.uspto.gov/statusview/sn99948009",
    "source": "USPTO TSDR (public record)"
}
```

### Data fields

| Field | What it is |
|---|---|
| `serialNumber`, `filingDate`, `status`, `statusDate` | Application identity & state |
| `markText`, `markDrawingType`, `register`, `markType` | The mark itself |
| `isProSe` | `true` when no attorney of record — the applicant filed themselves |
| `contactEmail`, `contactEmails` | Best contact email (pro-se: applicant's own; represented: attorney/correspondent) |
| `correspondentPhone`, `correspondentNameAddress` | Correspondence contact (name + address block as published) |
| `ownerName`, `ownerAddress`, `legalEntityType`, `ownerOrigin` | The applicant/owner |
| `attorneyName`, `attorneyEmail` | When represented |
| `intlClasses`, `usClasses`, `goodsServices` | What the mark covers |
| `tsdrUrl` | The public USPTO record this row was built from |

### Pricing, speed & politeness

This Actor is deliberately **low-rate and polite** to the official source: sequential requests with a ~3-second delay (measured as the source's comfortable envelope), a hard cap of 2,500 rows per run, and automatic cool-down on rate signals. Expect roughly **100 leads per 5-6 minutes**. Compute cost stays small (HTTP only, no browser); you pay per result.

### FAQ & legal

**Is this legal?** Trademark application data is US public record, published by USPTO for public inspection; USPTO-produced data is public domain. This Actor reads the public status pages at a polite, human-scale rate. **If you contact applicants, compliance is on you as the sender** — CAN-SPAM for email, and if you are an attorney, your bar's solicitation rules (many require solicitation notices). USPTO also [warns applicants about misleading solicitations](https://www.uspto.gov/trademarks/protect/caution-misleading-notices) — be one of the legitimate ones: clear identity, real value, no deception.

**Why don't I see yesterday's filings?** USPTO publishes new applications with a ~5-10 day capture delay (see the honesty note). Nobody has faster public data; this Actor always returns the newest that exists.

**Why is there a 2,500-row cap per run?** Politeness to the source beats burst speed — a reliable feed is worth more than a blocked one. Daily scheduled runs cover the full flow comfortably.

**Owner email vs correspondent email?** USPTO masks represented owners' own emails since 2020; the public contact is the attorney/correspondent. For pro-se filers the correspondence email is the applicant's own.

**Something broken?** Open an issue on the Issues tab — fixes ship fast.

### Changelog

#### 0.1 (2026-07-27)

- Initial release: freshest-published walk (frontier detection + descending collection), custom date-range backfill, serial range/list modes.
- Pro-se / attorney filtering, normalized `contactEmail`, incremental daily-feed support (*Only new since last run*).
- Measured politeness envelope (~3s pacing) with single 90s cool-down and hard per-run caps.

# Actor input Schema

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

New filings walks the freshest applications by date (the lead feed). Serial range / serial list fetch specific applications by US serial number.

## `datePreset` (type: `string`):

Freshest = the newest applications published in TSDR, walking back from the publication frontier — the same freshness every 'daily trademark leads' service actually has (USPTO publishes new applications with a ~7-10 day capture delay after filing; ~1,700-2,000 filings/business day). Custom = an explicit filing-date range for backfills.

## `onlyNewSinceLastRun` (type: `boolean`):

For scheduled daily feeds: stop when reaching the serials already fetched by the previous run, so each run returns exactly the new batch. First run just uses Max results.

## `dateFrom` (type: `string`):

YYYY-MM-DD filing date. Only used when Date range = Custom.

## `dateTo` (type: `string`):

YYYY-MM-DD filing date. Only used when Date range = Custom. Leave empty for 'today'.

## `filerType` (type: `string`):

Pro-se applicants filed WITHOUT an attorney — their own contact email is on the application (the classic IP-firm lead). Attorney-represented applications expose the attorney/correspondent contact instead.

## `serialFrom` (type: `integer`):

First US serial number (8 digits, e.g. 99900000). Only used in 'Serial number range' mode.

## `serialTo` (type: `integer`):

Last US serial number. Only used in 'Serial number range' mode.

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

Specific 8-digit US serial numbers to fetch. Only used in 'Specific serial numbers' mode.

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

Hard cap on dataset rows per run. Capped at 2,500 (about one full filing day) to keep access to the official source polite and reliable. At the polite pace this is roughly 100 records per 5-6 minutes.

## `includeGoodsServices` (type: `boolean`):

Add the full goods/services description per class. Adds detail; off makes rows leaner.

## `requestDelayMs` (type: `integer`):

Delay between requests to USPTO. Minimum 2500 ms is enforced — TSDR rate-protects bursts, and this actor deliberately stays low-rate and polite to the official source (~2 min per 100 records is expected).

## Actor input object example

```json
{
  "mode": "new_filings",
  "datePreset": "freshest",
  "onlyNewSinceLastRun": false,
  "filerType": "all",
  "serialNumbers": [],
  "maxResults": 40,
  "includeGoodsServices": true,
  "requestDelayMs": 3000
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "mode": "new_filings",
    "datePreset": "freshest",
    "filerType": "all",
    "maxResults": 40
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/uspto-trademark-leads").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 = {
    "mode": "new_filings",
    "datePreset": "freshest",
    "filerType": "all",
    "maxResults": 40,
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/uspto-trademark-leads").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 '{
  "mode": "new_filings",
  "datePreset": "freshest",
  "filerType": "all",
  "maxResults": 40
}' |
apify call foxlabs/uspto-trademark-leads --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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