USPTO Trademark Leads ™️

foXLabs US lead series: FMCSA carriers · Insurance producers · Employer benefit plans · Federal contractors

🎉 Turn USPTO trademark filings into lead data — no login, no API key, one row per application, with the applicant, the mark, the classes and the contact details on the record: correspondent e-mail and phone, attorney, owner address. Built for IP services, legal and B2B sales to new brands.

🔍 What is USPTO Trademark Leads — and when should you use it?

It answers two questions about the USPTO trademark register, live on every run:

• Who filed a trademark application in the last days? New filings mode lists the applications filed in the last 14 days, newest first — optionally only the ones filed without an attorney (pro se), in the classes you care about.
• Which applications belong to this owner, or carry this mark? Search mode finds applications anywhere in the register by owner name and/or mark text.

Every result is then read from its own USPTO status page, which is where the contact details are.

Use it when you need: a daily list of new applicants to reach out to; the filings of one company with their contact person; the applications behind a brand name.

Use something else when: you only need to know whether a phrase is already taken (a plain availability check does not need the contact details and is faster elsewhere), or you need company firmographics — this is trademark filings, not a company registry.

🤖 Use with AI agents

Already on the Apify MCP server? Ask for this Actor by name: foxlabs/uspto-trademark-leads.

Your agent can pay for its own runs. This Actor is pay-per-event with agentic payments, so an agent can discover it, run it and settle the bill over x402 (USDC on Base) or Skyfire — no Apify account or API token of its own. Billing is the same either way: per delivered record, never for errors.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

I want to pull US trademark filings with contact details using the Apify Actor `foxlabs/uspto-trademark-leads`.
Input: `mode` is `new_filings` (the latest filings), `search` (needs `markText` and/or `ownerName`), `serial_range` or `serial_list`. Optional filters: `filerType` (`pro_se_only` = filed without an attorney), `intlClasses`, `liveOnly`. `maxResults` caps how many results are returned; each result takes about 3 seconds.
Start with: {"mode":"new_filings","maxResults":20}
Ask me what to look up, run the Actor, then summarise the rows as a table.

The machine-readable API, MCP config and OpenAPI definition live at apify.com/foxlabs/uspto-trademark-leads.md.

📋 Overview

Why teams pick this actor:

• ✉️ The contact details on the record — correspondent e-mail and phone, attorney, owner address, as they stand at USPTO. In a run of 300 self-filed applications on 6 October 2026, every row had an e-mail and 205 had a phone.
• 🆕 Fresh filings — a new application shows up one to two days after it is filed (measured 2026-10-06: the filings of 5 October were available on 6 October).
• 🙋 Pro-se filter — keep only the applicants who filed without an attorney. On 5 October 2026 that was 627 of 1,779 filings.
• 🔎 Search the register — by owner name and/or mark text, with class and live-mark filters (13.3 million records on 2026-10-06).
• 🔁 Feeds that do not repeat — with "Only new since last run", a scheduled run delivers each filing once.
• 💰 Pay per delivered row — no subscription; the run stops at your spending limit and tells you.

✨ Features

• 📰 New filings feed — the last 14 days, or a custom filing-date range, newest first.
• 🔤 Search — every word of the mark text and/or the owner name must match; results newest first. The matching is USPTO's own: for mark text it can also return a mark that is spelled differently (a search for canopy in class 28 also returned KANOPEO).
• #️⃣ Serial lookup — a list or a range of US serial numbers.
• 🧾 One record shape in every mode — mark, filing date, status, classes, goods and services, owner (name, address, legal entity type), attorney, correspondent contact, link to the USPTO page.

🎬 Quick Start

curl -X POST "https://api.apify.com/v2/acts/foxlabs~uspto-trademark-leads/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"new_filings","maxResults":20}'

🚀 Getting Started (3 steps)

1. Choose the mode — New filings for the feed, Search for an owner or a mark, or serial numbers you already have.
2. Set the filters and the cap — filer type, classes, and maxResults (each result takes about 3 seconds).
3. Run and export — get the dataset as JSON, CSV or Excel.

📥 Input

{"mode":"new_filings","maxResults":20}

Field	Type	Description
mode	string	new_filings (default) — the lead feed. search — by mark text and/or owner name. serial_range / serial_list — specific applications by US serial number.
markText	string	Words to find in the mark — all of them must match. USPTO's index does the matching and can also return marks that are spelled differently. Required in search mode unless ownerName is given; narrows the feed in new_filings mode.
ownerName	string	Words that must all appear in the applicant / owner name. Required in search mode unless markText is given; narrows the feed in new_filings mode.
intlClasses	array	Keep only applications in at least one of these Nice classes (1-45), e.g. ["25"].
liveOnly	boolean	Leave out abandoned, cancelled and expired marks.
filerType	string	all (default), pro_se_only — filed without an attorney, attorney_only.
datePreset	string	freshest (default) — the last 14 days in new_filings mode, no date limit in search mode. custom — use dateFrom / dateTo.
onlyNewSinceLastRun	boolean	For scheduled feeds in new_filings mode: each run delivers only filings it has not delivered before, newest first, looking back up to 14 days. A run that is cut short leaves the rest for the next run. The memory is kept per set of filters. One run per feed at a time: a second run with the same filters that starts meanwhile ends at once.
dateFrom	string	YYYY-MM-DD filing date. Only used when datePreset is custom.
dateTo	string	YYYY-MM-DD filing date. Only used when datePreset is custom. Leave empty for today.
serialFrom	integer	First US serial number (8 digits). Only used in serial_range mode.
serialTo	integer	Last US serial number. Only used in serial_range mode.
serialNumbers	array	Specific 8-digit US serial numbers. Only used in serial_list mode.
maxResults	integer	Hard cap on dataset rows per run (default 300, at most 2,500).
maxRunSeconds	integer	Stop after this many seconds and keep the leads collected so far. 0 = no budget. The Actor also stops by itself 30 seconds before the run timeout.
includeGoodsServices	boolean	Add the full goods/services description per class (default on).
requestDelayMs	integer	Delay between USPTO status pages (default 3000, minimum 2500).

More recipes

• The newest self-filed applications in clothing: {"mode":"new_filings","filerType":"pro_se_only","intlClasses":["25"],"maxResults":50}
• Everything one company has filed: {"mode":"search","ownerName":"Landscape Structures","maxResults":25}
• Live marks containing a word, in one class: {"mode":"search","markText":"canopy","intlClasses":["28"],"liveOnly":true,"maxResults":25}
• A scheduled feed that delivers each new filing once: {"mode":"new_filings","filerType":"pro_se_only","onlyNewSinceLastRun":true,"maxResults":300}
• One application you already know: {"mode":"serial_list","serialNumbers":["99900001"]}

📤 Output

One row per application, saved to the dataset. Every run ends with a status message that says how many leads were delivered and, if the run stopped early, why.

Field	Description
serialNumber	US serial number
markText	The mark (word mark or literal elements)
filingDate	Application filing date (YYYY-MM-DD)
isProSe	true when no attorney is on the record
contactEmail / contactEmails	Correspondent e-mail (and attorney e-mail) on the record
correspondentPhone	Correspondent phone
correspondentNameAddress	Correspondent name and address
ownerName / ownerAddress	Applicant / owner and their address
legalEntityType / ownerOrigin	Owner's legal entity type and where it is organized
attorneyName / attorneyEmail	Attorney of record, if any
markDrawingType / markType / register	Kind of mark and register
status / statusDate	USPTO status text and its date
intlClasses / usClasses	International (Nice) and US classes
goodsServices	Goods and services text per class (optional)
tsdrUrl	Link to the USPTO status page
source / fetchedAt	Source label and fetch time

💼 Use cases

1. New-brand lead-gen — reach applicants while the filing is fresh. Input: {"mode":"new_filings","filerType":"pro_se_only","maxResults":300}. Output: the newest self-filed applications with the applicant's e-mail and phone.

2. IP services sales by class — a feed for one industry. Input: {"mode":"new_filings","intlClasses":["9","42"],"onlyNewSinceLastRun":true}. Output: each new software / tech filing once.

3. Account research — what a company has filed and who handles it. Input: {"mode":"search","ownerName":"Landscape Structures"}. Output: its applications, newest first, with attorney and correspondent.

🔗 Integration

JavaScript / Node.js

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/uspto-trademark-leads').call({"mode":"new_filings","maxResults":20});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);

Python

from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('foxlabs/uspto-trademark-leads').call(run_input={"mode":"new_filings","maxResults":20})
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

Written for apify-client 3 for Python, where call() returns a run object; with version 1 or 2 it returns a dict — write run['defaultDatasetId'] there.

Automation (n8n / Zapier / Make): schedule or webhook → HTTP request to the actor API with your input → handle the JSON dataset → push to a sheet, CRM or dashboard.

📊 Pricing

Pay-per-event: $0.006 per delivered record (≈ $6 per 1,000 leads), plus Apify's run-start event ($0.00005 per GB of run memory). A run that delivers nothing adds no record charge. View current pricing.

Spending limit. Before every USPTO status page the Actor checks the run's maximum charge — the limit you set for the run, or else what is left of your monthly usage limit. When there is no room for another lead it stops, keeps what it has delivered, and the status message says how many leads you got.

❓ FAQ

Do I need an account, login or API key? No.

Where does the data come from? Two public USPTO sources. The list of applications (who filed what, when) comes from the search service behind USPTO's own trademark search page; the contact details come from each application's TSDR status page. The search service is not a documented API: if it changes or stops answering, the run ends with a message that says so, and what was delivered is kept.

What do I search by? Mark text, owner name, international class, filer type (with or without attorney), filing date — or serial numbers.

How current is the data? Every run reads the sources live. A new application appears one to two days after it is filed.

Why does a run take a while? Each lead's contact details are read from its own status page with a pause of at least 2.5 seconds, to stay polite to the official source: about 100 leads per 5-6 minutes.

Does "Only new since last run" skip anything when a run stops early? No. The Actor remembers the filings it has delivered, per set of filters, and looks back 14 days on every run; whatever a run did not get to comes with the next one.

Can a lead come twice? The memory is written while the run goes (every 10 leads) and when the run ends, so a run that stops at maxResults or on a time or spending limit does not repeat its leads. An aborted run writes its memory too when Apify gives it the chance (a graceful abort). If a run is killed without warning — an immediate abort, a crash — the next run can deliver up to 10 of its last leads once more.

Can two runs of the same feed run at the same time? No, and the Actor prevents it, because both would deliver the same leads. A run with "Only new since last run" that starts while another run with the same filters is still going ends at once with a status message; it delivers nothing and does not contact USPTO. Feeds with different filters do not affect each other.

Can I export to CSV / Excel / JSON? Yes — directly from the Apify dataset.

🐛 Troubleshooting

• Fewer rows than expected — raise maxResults, or widen the filters. In search mode every word you type must be in the mark or the owner name.
• No rows for the newest day — filings appear one to two days after they are filed, so the newest day in the window is usually empty.
• The run ended with "stopped because the maximum charge … was reached" — the run's maximum charge, or what is left of your monthly usage limit, covered fewer leads than you asked for. The dataset holds the ones that were delivered; raise the limit and run again for the rest.
• The run ended with "USPTO's trademark search service … " — the search service did not answer this time. Nothing is wrong with your input; run again later. Serial number modes do not use the search service.
• The run ended with "another run of this same feed is in progress" — two runs with "Only new since last run" and the same filters overlapped: the earlier one was still going, or had been killed less than three minutes before. Nothing was delivered. Start the run again when the other one has finished; if a schedule causes it, make the interval longer than a run takes, or lower maxResults.
• A mark-text search returned a mark without my word — USPTO's index does the matching and also returns some marks that are spelled differently (for example KANOPEO for canopy). Filter the dataset on markText if you need the literal word.
• An application is missing its e-mail — the record has none: the Actor returns what the USPTO status page shows.

⚖️ Is it legal to scrape this data?

This actor reads the public USPTO trademark database. Results can still contain personal data (e.g. a person’s name); personal data is protected by the GDPR and similar laws, so only process it with a legitimate basis. See Apify’s blog post on the legality of web scraping. If you use the leads to market legal services, the attorney advertising and solicitation rules of your jurisdiction apply to you.

🤝 Support & contact

• 🌐 Website: data.foxlabs.com.tr
• 📧 Email: info@foxlabs.com.tr
• 🐛 Issues: open a ticket in the Actor’s Issues tab
• 🧰 More clean B2B data actors: Fox Labs on Apify

Changelog

0.1.13 — 2026-10-08 — README: the Python example works with the current Apify client

• The README's Python example read the results with run['defaultDatasetId']. With the current Apify client for Python (version 3) call() returns a run object, not a dict, and that line raised TypeError: 'Run' object is not subscriptable — after the run itself had finished. The example now reads run.default_dataset_id; with client version 1 or 2, keep run['defaultDatasetId']. Checked with apify-client 3.2.1, 2.5.1 and 1.12.2.
• No code, output field or pricing change.

0.1.12 — 2026-10-07 — a run that Apify starts again keeps to maxResults

• A run that the platform starts again no longer writes past maxResults or repeats rows. Apify can move a run to another server while it is going; the Actor then starts again with the same dataset. Until now it started counting from zero: a run with maxResults 30 that was started again after 14 rows ended with 44 rows, 4 of them written twice. The Actor now first reads what its own dataset already holds — those leads count towards maxResults and are not written again. All four modes.
• No output field changed, no pricing change.

0.1.11 — 2026-10-07 — fresh filings again, and search by mark text or owner name

• New filings mode returns new filings again. Since about 20 July 2026 it had been returning the same filings of that date as "the freshest": USPTO changed how it numbers applications (a new 50… series since 18 July 2026, and 99… numbers no longer in filing order), and the Actor found new filings by walking down from the highest serial number. It now gets the list of applications by filing date from USPTO's search service and reads the contact details from each application's status page as before. Measured on 2026-10-06: the filings of 5 October were available (1,779 that day, 627 without an attorney), and a run no longer starts by spending about two minutes looking for the newest serial number.
• New: Search mode ("mode":"search") — find applications anywhere in the register by markText and/or ownerName; every word must match; newest first.
• New filters for New filings and Search: intlClasses (Nice classes) and liveOnly. markText and ownerName also narrow the New filings feed.
• Behaviour change — onlyNewSinceLastRun: the Actor now remembers the filings it has delivered (per set of filters) and looks back 14 days on every run. Each filing is delivered once; whatever a run does not get to (Max results, a time limit, your spending limit) comes with the next run. The first runs of a new feed therefore work back through the last 14 days before they are down to only the newest filings.
• onlyNewSinceLastRun — the memory is written while the run goes (every 10 leads), when it ends and on a graceful abort. A run that is killed without warning can repeat at most its last 10 leads in the next run.
• onlyNewSinceLastRun — one run per feed at a time. A run that starts while another run with the same filters is still going ends at once with a status message, without delivering anything or contacting USPTO: two at once would deliver the same leads twice.
• Behaviour change — pro-se filter: it is applied when the list is made, so the run no longer spends requests on applications that have an attorney.
• If USPTO's search service does not answer, the run ends with a message that says so; rows already delivered are kept. Serial number modes do not use it.
• serialFrom / serialTo accept the 50… series.
• No output field changed, no pricing change.

0.1.9 — 2026-10-07 — a run that is cut short stops cleanly, says why, and the next one carries on

• A run that reaches its maximum charge now stops by itself and tells you. The maximum charge is the limit you set for the run, or else what is left of your monthly usage limit. Until now the Actor did not look at it: the scan went on, leads past the limit were logged as pushed but left out of the dataset, and a longer run was aborted by Apify. The Actor now checks the room left before every USPTO request, stops the scan when there is none, and finishes as a normal run with a status message that says how many leads were delivered.
• onlyNewSinceLastRun: a cut-short run no longer loses the rest of its batch. A run that stops early — at maxResults, on a time limit, or on its maximum charge — saves the part it did not reach, and the next incremental run continues with it after the new filings. Nothing is skipped and nothing is delivered twice. Before, the rest of that batch was never delivered. For a daily feed whose maxResults is smaller than the day's filings this means a run can now also return filings older than the previous run's newest one.
• The time limits hold. The Actor stops 30 seconds before the run timeout instead of being cut off by it, and maxRunSeconds also covers the first step, locating the newest filing.
• Every run ends with a status message that says what was delivered and, for a partial run, why it stopped.
• No output field changed, no pricing change.

0.1.8 — 2026-09-20 — README examples corrected against the real input schema

• The README's code examples did not match this Actor. They used queries and maxResultsPerQuery — keys that do not exist in this Actor's input schema — with a placeholder value, and the input table listed those same phantom fields. Anyone who copied the AI-agent, cURL, JavaScript or Python example got a failing run. Every example now uses the real schema and matches the Console prefill: {"mode":"new_filings","maxResults":20}
• The input table is regenerated from input_schema.json, so it lists the fields the Actor actually accepts.
• Removed claims carried over from the same generator template where present: "formation / status monitoring", "a canonical registry record for KYB and due diligence", "every row carries query", and industry described as a NACE code.
• No code, output field or pricing change.

0.1 — 2026-09-07

• Enabled AI-agent payments (x402) + rebuilt the README to the full standard (What-is / when, AI-agents + x402 agentic payments + MCP, Overview, Features, Use cases, Integration, FAQ, Troubleshooting, Support & contact).

0.0

• Initial release: data from the USPTO trademark database (official open data) by name or registry ID.