# USPTO Trademark Search API: Bulk Name Availability Check (`hanielazevedo/uspto-trademark-bulk-check`) Actor Check hundreds of brand names against official USPTO trademark data in one run: exact, sound-alike and contains matches with owner, Nice classes, status, dates, goods/services and a conflict risk flag. Filter by class and live/dead. $0.01 per name. - **URL**: https://apify.com/hanielazevedo/uspto-trademark-bulk-check.md - **Developed by:** [Haniel Azevedo](https://apify.com/hanielazevedo) (community) - **Categories:** Business, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $10.00 / 1,000 term checkeds 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/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 Check **hundreds of brand names, product names or slogans against official USPTO trademark records in one run**. For every name you get a **conflict risk flag** (high / medium / low / none), the reason, and the best matching US trademarks: mark text, serial and registration number, live/dead status, filing and registration dates, owner, Nice classes, a goods/services snippet and the **match type** (exact, sound-alike or contains). Built for founders naming a startup, Amazon/Etsy/print-on-demand sellers screening designs and listing titles, agencies shortlisting brand names, domain investors, and IP teams who want a fast first pass before a full clearance search. 📅 USPTO data current through: **2026-11-01** (refreshed weekly from the USPTO's official daily trademark files; every result also carries `dataThrough`). > **Not legal advice.** This is an automated screening of USPTO records, not a clearance opinion. A "none" or "low" result does not mean a name is free to use or register (common-law rights, state marks, foreign marks, design marks and likelihood-of-confusion analysis are out of scope). Talk to a trademark attorney before you file or launch. ### How it works 1. The Actor ships with a **search index of the full USPTO trademark database** (about 12.9 million US word marks, 4.5 million of them live, from 1870 to today), built from the USPTO's official bulk data on the [USPTO Open Data Portal](https://data.uspto.gov/) (Trademark Full Text XML Data, annual backfile + daily files). The date the data runs through is in every result as `dataThrough`. 2. Each name is normalized (case, spaces, punctuation and accents ignored) and matched three ways: - **exact**: same letters and digits (`Nike` = `NIKE` = `N.I.K.E`) - **phonetic**: sounds alike (`Nyke`, `Nikki` for `Nike`), using a Metaphone sound key plus a Jaro-Winkler similarity check of at least 0.75 to keep noise down - **contains**: the mark contains every word of your name (`NIKE AIR`, `NIKELAB`) 3. Results are filtered by your Nice classes and live/dead status, ranked (exact > phonetic > contains, live first, your classes first) and a risk flag is set. No scraping of USPTO websites and no third-party data: only USPTO's documented bulk data products. #### Risk flag | Level | Meaning | |---|---| | `high` | A **live** mark with exactly the same name exists in one of your classes (or in any class if you set none) | | `medium` | A live sound-alike mark in your classes, or an exact live mark only in other classes | | `low` | Only marks that contain your words, or only dead marks | | `none` | No match found in the index | The flag always looks at live marks, even if you ask for dead marks only. ### Input | Field | Default | What it does | |---|---|---| | `terms` | – | Names / phrases to check, one per entry (up to 10,000 per run) | | `serialNumbers` | – | Optional USPTO serial numbers to look up directly (8 digits) | | `registrationNumbers` | – | Optional USPTO registration numbers to look up directly | | `niceClasses` | all | Nice classes 1-45, e.g. `["25"]` clothing, `["9","42"]` software | | `status` | `live` | `live`, `dead` or `all` | | `matchTypes` | all three | Any of `exact`, `phonetic`, `contains` | | `maxResultsPerTerm` | 20 | Matches listed per term (counts always cover all matches) | | `includeGoodsServices` | true | Add a goods/services snippet for live marks | | `usptoApiKey` | – | Optional: your own free USPTO Open Data Portal key to also apply the newest daily USPTO files in your run | Example: screen three candidate names for a clothing brand. ```json { "terms": ["Nike", "Spellkin", "Zorblaxitron"], "niceClasses": ["25"], "status": "live", "maxResultsPerTerm": 10 } ``` ### Output One dataset item per checked name or number. Real example (trimmed to one match): ```json { "inputType": "term", "term": "Nike", "normalizedTerm": "nike", "phoneticKey": "NK", "riskLevel": "high", "riskReason": "Exact live mark 'NIKE' (serial 98029846) in class 25", "exactLiveMatch": true, "matchCount": 91, "matchCountCapped": false, "exactLiveCount": 8, "exactDeadCount": 0, "phoneticLiveCount": 54, "phoneticDeadCount": 0, "containsLiveCount": 29, "containsDeadCount": 0, "exactLiveInOtherClasses": 25, "matches": [ { "matchType": "exact", "similarity": 1.0, "mark": "NIKE", "serialNumber": "98029846", "registrationNumber": "7401694", "live": true, "statusCode": 700, "status": "Registered", "statusDate": "2024-05-28", "filingDate": "2023-06-06", "registrationDate": "2024-05-28", "owner": "Nike, Inc.", "niceClasses": [ "10", "18", "21", "25", "26", "27" ], "goodsServices": "Hair accessories, namely, hair ties and hair bands; Yoga mats; bags specially adapted for yoga mats; Lunch bags not of paper, lunch boxes; water bottles sold empty; Sports bags, handbags, backpacks, duffle bags, purses, shoulder bags, tote bags, gym...", "pseudoMark": null, "tsdrUrl": "https://tsdr.uspto.gov/#caseNumber=98029846&caseType=SERIAL_NO&searchType=statusSearch" } ], "niceClassesFilter": [ "25" ], "statusFilter": "live", "dataThrough": "2026-11-01", "checkedAt": "2026-11-02T21:40:00+00:00", "disclaimer": "Automated screening of USPTO records, not legal advice and not a clearance opinion. Consult a trademark attorney before filing or launching.", "error": null } ``` Main fields: - `riskLevel`, `riskReason`, `exactLiveMatch` - `matchCount` plus counts per type and status (`exactLiveCount`, `phoneticLiveCount`, `containsLiveCount`, `exactDeadCount`, …) and `exactLiveInOtherClasses` - `matches[]`: `mark`, `matchType`, `similarity`, `serialNumber`, `registrationNumber`, `live`, `status`, `statusCode`, `statusDate`, `filingDate`, `registrationDate`, `owner`, `niceClasses`, `goodsServices`, `pseudoMark`, `tsdrUrl` (opens the official USPTO TSDR record) - `dataThrough`: date of the newest USPTO data used Invalid inputs (blank, symbols only, malformed numbers) come back as items with an `error` and are not charged. A run summary is saved as `RUN_SUMMARY` in the key-value store. The dataset has two views: **Risk overview** (one row per name) and **Matching marks** (one row per match). ### Pricing Pay per event, no subscription: | Event | Price | |---|---| | Term checked (each unique name, serial or registration number, including names with zero matches) | **$0.01** | | Actor start | $0.00005 | | Invalid inputs and duplicates | free | 100 names cost about $1.00; 1,000 names about $10.00. Use the run's maximum cost setting to cap spend; the Actor stops cleanly when it is reached. ### FAQ **How fresh is the data?** The bundled index is refreshed every week from the USPTO's official daily trademark files (new filings, status changes such as live to dead, owner changes). The date is at the top of this page and in every result as `dataThrough`. For same-week freshness, add your own free USPTO API key (`usptoApiKey`) and the run applies the newest daily files first (adds roughly 10-60 seconds, no extra charge). **Does it check design (logo) marks?** It checks the words of every mark, including the word element of design marks. It does not compare images. **Why is a dead mark relevant?** Dead marks are not enforceable registrations, but they show past use and can hint at common-law rights. They are hidden by default (`status: live`). **What about state, EU or other foreign trademarks?** Only US federal (USPTO) records are covered. **Is a name with risk "none" safe?** No. It means no similar word mark was found in USPTO records by this automated search. A trademark attorney can run a full clearance search. **Is my USPTO API key stored?** No. It is a secret input used only inside your own run to download USPTO daily files, and it is never written to the dataset, logs or key-value store. **Where does the data come from?** USPTO Trademark Full Text XML Data (annual backfile and daily applications files), downloaded from the USPTO Open Data Portal. Source: USPTO. This Actor is not affiliated with or endorsed by the USPTO. # Actor input Schema ## `terms` (type: `array`): One name, word or phrase per line (up to 10,000 per run, 120 characters each). Each unique name costs one 'term-checked' event, whether or not anything matches. Blank or symbol-only entries are reported as invalid and are free. Duplicates (same letters and digits) are checked once. ## `serialNumbers` (type: `array`): USPTO application serial numbers to look up directly, e.g. 72414176 (8 digits). Each valid number costs one 'term-checked' event; malformed numbers are free. ## `registrationNumbers` (type: `array`): USPTO registration numbers to look up directly, e.g. 978952 (1-7 digits). Each valid number costs one 'term-checked' event; malformed numbers are free. ## `niceClasses` (type: `array`): Only return marks in these international (Nice) classes, 1-45, e.g. 25 for clothing, 9 for software, 35 for retail. Leave empty for all classes. Old marks with only US classes are always included. The risk flag is 'high' only when an exact live mark exists in one of these classes. ## `status` (type: `string`): Which marks to return. The risk flag is always based on live marks. ## `matchTypes` (type: `array`): Which kinds of matches to return. Exact ignores case, spaces and punctuation. Phonetic uses a sound-alike key plus a similarity check. Contains finds marks that include every word of your term. ## `maxResultsPerTerm` (type: `integer`): Maximum matches listed per term, best first (exact, then phonetic, then contains; live before dead; your classes first). Match counts always reflect all matches found. The price is per term, not per match. ## `includeGoodsServices` (type: `boolean`): Add the first ~250 characters of each live mark's goods/services description. ## `usptoApiKey` (type: `string`): Optional. The bundled index is refreshed regularly from USPTO bulk data (the date is in every result as 'dataThrough'). Add your own free USPTO Open Data Portal key (https://data.uspto.gov/apis/getting-started) to also apply the newest daily USPTO files in your run. Adds ~10-60 s; no extra charge. The key is used only for your run and never stored or shown. ## Actor input object example ```json { "terms": [ "Nike", "Spellkin", "Zorblaxitron" ], "status": "live", "matchTypes": [ "exact", "phonetic", "contains" ], "maxResultsPerTerm": 20, "includeGoodsServices": true } ``` # Actor output Schema ## `results` (type: `string`): One item per checked term or number: risk level and reason, match counts, the best matching USPTO marks (mark, serial, registration, status, dates, owner, classes, goods/services, match type) and dataThrough, the date the USPTO data is current through. ## `summary` (type: `string`): Inputs, checked and charged counts, risk totals, invalid and duplicate inputs, dataThrough (the date the USPTO data is current through) and why the run stopped. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "terms": [ "Nike", "Spellkin", "Zorblaxitron" ] }; // Run the Actor and wait for it to finish const run = await client.actor("hanielazevedo/uspto-trademark-bulk-check").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "terms": [ "Nike", "Spellkin", "Zorblaxitron", ] } # Run the Actor and wait for it to finish run = client.actor("hanielazevedo/uspto-trademark-bulk-check").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 '{ "terms": [ "Nike", "Spellkin", "Zorblaxitron" ] }' | apify call hanielazevedo/uspto-trademark-bulk-check --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,hanielazevedo/uspto-trademark-bulk-check" } } } ``` 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 ` 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/MC9RsjHldPpiJlMkZ/builds/6vZlsnqwl2gzcCSC5/openapi.json