US Trademark Status and Watch (USPTO TSDR)

What does US Trademark Status and Watch do?

US Trademark Status and Watch reads USPTO's official TSDR API (Trademark Status and Document Retrieval) for the US trademarks you list and returns one row per mark with the facts a brand owner or a trademark practice checks first: the serial and registration numbers, the mark and its type, the current status with USPTO's own description and date, the filing, registration, publication, abandonment and cancellation dates, the owner, the attorney of record, the classes with their goods and services, and the latest event in the prosecution history. Each registered mark also gets its next maintenance deadlines, computed from the registration date: the Section 8 declaration, the Section 9 renewal and their grace periods, each with the rule it was computed from, plus one deadlineStatus such as section8_window_open or renewal_due_within_90_days.

It has two modes. Check returns every mark you give it. Watch is made for a schedule: the first run delivers every mark as a baseline, and later runs deliver only the marks that changed, with a list of what changed and its old and new value. A watch run in which nothing changed writes one free row that says so.

The Actor uses the TSDR API, never the TSDR website, and keeps one request a second. Rows keep owner and attorney names as the public record shows them, but no email address, phone number or street address of anyone. The Actor is not affiliated with USPTO, and its output is not legal advice. Every deadline is computed by the Actor from the record and must be checked before you file anything.

Why use US Trademark Status and Watch?

TSDR shows one mark at a time, and its status page does not tell you when a Section 8 declaration or a renewal falls due. A portfolio of marks means opening each page, reading the registration date and working the dates out by hand, then doing it again next month to see what moved. This Actor reads the whole list, works out the deadlines, and on a schedule tells you only what changed.

What you get:

• Deadlines with their rule. For each registered mark: when the Section 8 (or, for a Madrid registration, Section 71) window opens, when it is due, when its grace period ends, the same for the Section 9 renewal, whether a filing for the current period is on record, and the regulation each date comes from.
• One status word per mark. deadlineStatus sorts every mark into one of 17 states, so a filter on section8_due_within_90_days or renewal_grace_period finds the marks that need work.
• A watch that charges only for changes. A change in status, status date, registration number, owner, attorney, prosecution history or deadline status is delivered with each field's old and new value. A run with no change costs nothing beyond the start fee.
• One row for every input. A number TSDR does not hold, an entry that is not a number, and a repeat in your list each get a clear free row.
• Your own key, or a trial. Add your own free TSDR API key for up to 500 marks a run. Without one, the Actor's built-in key gives a trial of 10 marks a run.

Each claim above has a test behind it:

What you get	How it works	The test that backs it
Deadlines with their rule	The Section 8 period ends on the 6th anniversary of registration and then on every 10th, each with a window of one year before and 6 months of grace after (37 CFR 2.160 and 2.182). A last day on a weekend or a Washington DC federal holiday moves to the next business day (37 CFR 2.196). Filings and acceptances are read from the prosecution history.	"2.160 and 2.182: the 6-year period, then every 10th anniversary, each with a 1-year window and 6 months of grace", "2.196: a last day the Office is closed moves to the next business day", "every deadline status for a 6-year Section 8, day by day around its dates". Checked by hand against TSDR and the regulations for three marks on 14 Oct 2026, and USPTO's own courtesy reminders were dated on the computed window openings.
One status word per mark	Each state is one rule over the dates and the filings on record, and the list of states is fixed.	"every status the code can return is listed in DEADLINE_STATUSES", "recorded marks on 13 Oct 2026: window open, renewal due, grace period, filed, renewed, Madrid, dead, pending".
A watch that charges only for changes	The Actor keeps the last delivered state of each mark in a named key-value store. A new prosecution entry is found by its entry number, and a deadline that moves into a new state is a change even when TSDR shows nothing new.	"watch: the first run is the baseline, the second delivers and charges nothing, then a change is delivered with what changed", "watch: a deadline that enters its grace period is delivered as a change with no new TSDR data", and the live test "live: watch mode twice on the same list delivers the baseline, then nothing and no charge" (13 Oct 2026).
A row for every input	Serial numbers have 8 digits and registration numbers up to 7, with or without commas, slashes or an sn or rn in front.	"check mode on the recorded portfolio: each case reads as its record says, whatever way the number was written", "not found, invalid, duplicate and removed entries each get a free row that says why".
Your own key, or a trial	With your key in apiKey, a run reads up to 500 marks. Without it, the built-in key stops at 10 and writes a free row that explains how to add yours.	"C1 the built-in trial key reads 10 marks per run; the rest are one free row that names the fix", "C2 the user's own key lifts the cap".
Inside the TSDR rate limit	One request a second. An HTTP 429 answer (too many requests) is waited out for its Retry-After time, or 60 seconds, and three in a row stop the run.	"N1 a 429 is waited out for its Retry-After, and the mark is still read", "N2 three 429s in a row stop every request; what was not read is one free row, and the run keeps what it read", "N6 requests are one second apart at real speed".
Your key stays secret	apiKey is a secret input, encrypted by Apify. The Actor sends it only in the USPTO-API-KEY header to TSDR and never writes it to a row, the summary, the memory or the log.	"K3 neither key reaches the dataset, the stores or the log, even with every request logged".
A refused key is not a list of missing marks	TSDR answers a key it does not know with the same HTTP 404 it uses for a missing mark. When that happens before any mark was read, the Actor reads one well known mark to tell the two apart, and stops with a clear message when TSDR refuses the key.	"K2 an own key TSDR does not know says so, and the built-in key is not tried in its place", and the live test "live: a key TSDR does not know gets the gateway 404; one check, then the run stops and fails instead of listing marks as not found".
No contact details	Street addresses, cities, postcodes, email addresses and phone numbers are dropped when the record is read. An individual owner keeps the name and the country only.	"no street address, city, postcode, email address or phone number reaches the facts", "an individual owner keeps the name and the country only".
Charged only for what you get	One charge per row with status ok. Every other row is free, and the run stops before it would charge past your maximum cost per run. A run that restarts reads its own rows first.	"C3 the maximum cost per run stops delivery cleanly, and a watch delivers what was held back next time", "B2 a crash after a row is written but before the memory is saved delivers and charges nothing twice".

Plus what the Apify platform adds around it:

• API access. Start runs and read results with the Apify API or the JavaScript and Python clients.
• Scheduling. Run the watch every Monday morning and get only what moved that week.
• Integrations. Send rows to Make, Zapier, Google Sheets, Slack or any webhook.
• Monitoring. Run history, logs and alerts for failed runs.

Typical uses are a monthly deadline report for a portfolio of registrations, a weekly watch of a client's marks for office actions, oppositions, assignments and acceptances, a check of the marks named in a licence or an acquisition, and a list of marks whose grace period has started.

What data can US Trademark Status and Watch extract?

Each mark becomes one row in the dataset. The most useful fields:

Field	Type	What it holds
status	string	ok, not-found, invalid, failed, skipped, removed or no-changes.
input	string	The number as you gave it.
serialNumber, registrationNumber	string	The 8-digit serial number and the 7-digit registration number (empty if never registered).
markText, markType, standardCharacters	string, string, boolean	The words of the mark, word, design, both or other, and whether it is claimed in standard characters.
statusCode, statusDescription, statusDate	number, string, string	USPTO's 3-digit status code, its own sentence for it, and the date.
statusLife, statusStage, statusGroup	string	live or dead, application or registration, and one word such as examination, published, opposition, registered, abandoned or cancelled.
filingDate, registrationDate, publicationDate, abandonmentDate, cancellationDate	string	Dates as YYYY-MM-DD.
register, filingBasis, madrid	string, array, boolean	principal or supplemental, the filing bases such as 1(a) or 66(a), and whether the registration came in through the Madrid Protocol.
ownerName, ownerType, ownerEntityType, ownerCountry, ownerRegion, ownerRole	string	The current owner (the newest owner group, so an assignee after an assignment), company, individual or mixed, USPTO's legal entity type, the country, and the state of a company owner.
attorneyName	string	The attorney of record. No address, email or phone number.
classNumbers, classes	array	The international classes, and per class the goods and services text, class status and first-use dates.
lastEventCode, lastEventDescription, lastEventDate, eventCount	string, string, string, number	The newest entry of the prosecution history, and how many entries it has.
deadlineStatus, nextDeadline, daysToNextDeadline	string, string, number	Where the mark stands on its next filing, the next date that matters, and the days to it.
affidavitType	string	Which declaration the dates are for, such as section8_6_year, section8_10_year or section71_6_year.
section8WindowOpens, section8Due, section8GraceEnds, section8FiledOn, section8Rule	string	The computed Section 8 (or 71) dates, a filing found for this period, and the rule.
renewalWindowOpens, renewalDue, renewalGraceEnds, renewalFiledOn, renewalRule	string	The same for the Section 9 renewal. Empty for a Madrid registration, which renews at WIPO.
lastAcceptedFilingPeriod, lastAcceptedFilingOn	string	The latest declaration the record shows as accepted, such as 6_year, and when.
deadlinesComputed	boolean	True when the row's deadline dates were computed. They always are computed by this Actor, never read from USPTO.
changeType, changes, newEvents, stateStore	string, array, array, string	Watch mode: baseline or changed, one { field, old, new } per change, the prosecution entries added since the last delivered row, and the memory's store name.
tsdrUrl	string	The mark's page on TSDR.
error, errorCode	string	Why a row is not ok, as a sentence and as a short code.

The deadline states:

deadlineStatus	Meaning
no_filing_due_yet	Registered, and the next window has not opened.
section8_window_open, section8_due_within_90_days, section8_grace_period, section8_filed	The 6-year Section 8 declaration: window open, last day within 90 days, grace period running, or filed for this period.
renewal_window_open, renewal_due_within_90_days, renewal_grace_period, renewal_filed	A 10-year Section 8 declaration with its Section 9 renewal, in the same four states.
section71_window_open, section71_due_within_90_days, section71_grace_period, section71_filed	The same for a Madrid registration's Section 71 declaration.
grace_period_ended	No filing for the period is on record and the grace period is over, so the registration may be cancelled.
not_registered	A pending application. No maintenance deadline applies yet.
dead	Abandoned, cancelled or expired.
unknown	The record lacks what the rules need, such as a registration date. The rule fields say what is missing.

The Overview view shows status, owner, latest event and next deadline. The Deadlines view shows the Section 8 and renewal dates and the days left. The Changes view shows what a watch run found.

Every row that is not ok carries one of these codes in errorCode, so you can count rows by reason without reading the sentence. The sentence in error can be reworded in a later version. The code stays.

errorCode	Meaning
not-found	TSDR has no status record for that number. A very new filing can take a few days to appear.
invalid-number	The entry is not a serial number (8 digits) or a registration number (up to 7 digits).
duplicate	The mark is already in your list, so it was read once.
removed-on-request	The mark was removed from this Actor's output on request.
no-changes	A watch run in which no mark changed.
trial-limit	The built-in trial key reached its cap of 10 marks for this run. Add your own key in apiKey.
run-limit	Your own key reached the cap of 500 marks for one run.
charge-limit	The run reached your maximum cost per run.
run-time-limit	The run reached its time limit.
rate-limited	TSDR answered "too many requests" (HTTP 429) three times in a row.
key-refused	TSDR did not accept the API key.
repeated-failures	Five marks in a row failed with a server or network error, so the run stopped.
aborted	The run was stopped.
backend-404	TSDR's gateway answered 404 for this mark although the key works for others. Try again later.
server-error, http-error	TSDR answered with an error status.
network-error, timeout	TSDR could not be reached, or did not answer within 30 seconds.
too-large, bad-response, unexpected-redirect	An answer over 5 MB, an answer the Actor could not read, or a redirect to another site.
other	Any other reason. The sentence in error says what happened.

How to check US trademarks and watch them for changes

1. Open the Actor in Apify Console and select the Input tab.
2. The form is prefilled with check mode and three registrations (COCA-COLA, GOOGLE and JUST DO IT.), so you can press Start to see a result straight away. The run takes about 4 seconds and shows, for one, that the COCA-COLA registration of 1928 opens its next renewal window on 31 January 2027.
3. Add your own free TSDR API key in Your TSDR API key (apiKey). It takes three steps, as USPTO's TSDR API Key Manager guide describes them:
   1. Open the API Key Manager at https://account.uspto.gov/api-manager/ and sign in with your USPTO.gov account. If you have none, create one from the same page; it is free.
   2. Select TSDR (Trademark Search and Data Retrieval) API in the list and press Request API key.
   3. Your new key appears under My API keys with its expiration date. Copy it into apiKey. USPTO asks that keys are not shared, so use one from your own account.
4. Put serial or registration numbers in Serial or registration numbers, one per line. 97123456, sn97123456, 0238145, 238145, rn238145 and 6,500,000 all work.
5. For a watch, set What to do to watch. If you will add or remove marks later, also set Watch memory name (stateStoreName), such as my-portfolio-watch, so the memory survives the edit.
6. Press Start. A run reads about one mark a second.
7. Open the Output tab for the table, and export it as JSON, CSV or Excel. For a watch, create a schedule with the same input, for example every Monday at 8:00 New York time.

To run it from code, send the same input to the Actor through the API:

{
    "mode": "watch",
    "marks": ["0238145", "sn97123456", "6,500,000"],
    "stateStoreName": "my-portfolio-watch",
    "apiKey": "your-tsdr-api-key"
}

How to send trademark changes to Slack or Google Sheets (Make, Zapier, no code)

After the first run, a scheduled watch holds only the marks that changed since the last run, so you can pass every run's results straight on.

Slack, built in. On the Actor's Integrations tab, add Slack, connect your workspace, pick a channel and choose the event "Run succeeded". Each finished run posts a message with a link to its results.

Google Sheets with Make.com.

1. In Make, create a scenario and add the Apify module that watches for finished Actor runs, set to this Actor.
2. Add the Apify module that gets dataset items, and map the run's default dataset ID.
3. Add Google Sheets "Add a Row" and map the fields you want, for example markText, serialNumber, statusDescription, lastEventDescription, deadlineStatus, nextDeadline and tsdrUrl.
4. Optional: add a filter so only rows with status ok reach the sheet, or only marks whose deadlineStatus ends in _due_within_90_days or _grace_period.

Google Sheets or Slack with Zapier. Use the Apify trigger for a finished Actor run, then the Apify step that fetches dataset items, then a Google Sheets "Create Spreadsheet Row" or a Slack "Send Channel Message" action. A Zapier filter step works the same way as the Make filter.

Your own code. Add a webhook on the Integrations tab for the event "Run succeeded", and read the dataset from the URL in the payload.

Set the schedule first (see the steps above), so that each run, and each message or row, covers what changed since the run before.

How much does it cost to check US trademarks?

You pay per mark delivered, and the Apify platform usage for the run is included. A mark costs $0.01 on the Free and Bronze plans, so 1,000 marks cost $10.

Event	When it is charged	Price
trademark	One mark row delivered with status ok: every mark in check mode; in watch mode every mark of the first run, then each mark that changed	$0.01 (Free, Bronze), $0.009 (Silver), $0.008 (Gold)
Actor start	Once per run, scaled by memory (Apify standard event)	$0.00005 per GB of memory

Rows with the status not-found, invalid, failed, skipped, removed or no-changes cost nothing, and a mark that appears twice in your list is charged once. You can cap a run with the Maximum cost per run setting, and the Actor stops cleanly at that limit.

How much does one mark cost?

One mark costs $0.01 on the Free and Bronze plans, $0.009 on Silver and $0.008 on Gold, in both modes. A run adds a start fee of about $0.0000125 at the default memory of 256 MB. As a guide: a check of 500 marks costs $5.00. A watch of 200 marks starts with a baseline of $2.00, and then, with about 5 changes a week, costs about $0.05 a week.

How do I keep a run within budget?

Set Maximum cost per run when you start it or in the schedule. The run stops before it would charge past that amount, and the marks it did not deliver get one free skipped row with the code charge-limit. In watch mode those marks stay out of the memory, so the next run delivers them.

What does a watch run cost when nothing changed?

Only the start fee, about $0.0000125 at 256 MB. The run writes one no-changes row and charges nothing for it. A first watch run is a baseline and is charged for every mark, so do not run a separate check first: the watch's first run is the check.

Do I need my own API key?

For more than a quick try, yes. The Actor's built-in key belongs to one USPTO.gov account and is shared by every user, so a run on it stops at 10 marks. With your own free key the cap is 500 marks a run, and you have USPTO's limit of 60 requests a minute to yourself. The price is the same either way.

Input

Open the Input tab to see every setting with a short description. Only marks is required. The form has three groups:

• Marks: mode (check or watch), marks and includeGoodsAndServices.
• Watch mode: stateStoreName.
• Your TSDR key: apiKey, a secret field.

marks takes up to 500 entries. An 8-digit number is read as a serial number and a number of up to 7 digits as a registration number. Commas, slashes and spaces are ignored, and sn or rn in front makes the kind explicit.

includeGoodsAndServices is on by default. Turned off, the classes keep their numbers, status and first-use dates but leave out the goods and services text, which makes rows much smaller. Each class's text is cut at 5,000 characters, with goodsAndServicesTruncated set.

stateStoreName names the key-value store that remembers a watch. Left empty, the name is worked out from the list itself, so a changed list starts a new memory and the next run delivers (and charges) every mark again as a baseline. With a name, adding a mark delivers only that mark as a baseline, and a removed mark is simply no longer read.

Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. A run also writes a SUMMARY record to its key-value store with the mode, which key was used (own or built-in, never the key itself), the cap, the date used for the deadlines, the counts of marks read, delivered, delivered as a baseline, changed, unchanged, not found, invalid, failed, skipped and removed, the charged rows, the reason the run stopped early if it did, the watch memory's name, and the requests sent. A run in which the key was refused, or in which no mark could be read, ends with the status Failed and the reason in its message, and the rows stay in the dataset.

A registration whose renewal is due, and a number TSDR does not hold, look like this:

[
    {
        "status": "ok",
        "errorCode": null,
        "error": null,
        "input": "5065000",
        "serialNumber": "86530615",
        "registrationNumber": "5065000",
        "markText": "RETHINKING AUTOMOTIVE",
        "markType": "word",
        "standardCharacters": true,
        "statusCode": 702,
        "statusDescription": "A Sections 8 and 15 combined declaration has been accepted and acknowledged.",
        "statusDate": "2023-04-26",
        "statusLife": "live",
        "statusStage": "registration",
        "statusGroup": "registered",
        "filingDate": "2015-02-10",
        "registrationDate": "2016-10-18",
        "publicationDate": "2015-07-14",
        "register": "principal",
        "filingBasis": ["1(a)"],
        "madrid": false,
        "ownerName": "CAROFFER, LLC",
        "ownerType": "company",
        "ownerEntityType": "LIMITED LIABILITY COMPANY",
        "ownerCountry": "US",
        "ownerRegion": "TX",
        "ownerRole": "SUBSEQUENT OWNER AFTER REGISTRATION",
        "classNumbers": ["042"],
        "classes": [
            {
                "classNumber": "042",
                "goodsAndServices": "Development of technologies for others for automotive sales processes; information technology consultation; ...",
                "goodsAndServicesTruncated": false,
                "classStatus": "ACTIVE",
                "firstUseDate": "2015-01",
                "firstUseInCommerceDate": "2015-01"
            }
        ],
        "lastEventCode": "REM2",
        "lastEventDescription": "COURTESY REMINDER - SEC. 8 (10-YR)/SEC. 9 E-MAILED",
        "lastEventDate": "2025-10-18",
        "eventCount": 35,
        "deadlinesComputed": true,
        "deadlineStatus": "renewal_due_within_90_days",
        "nextDeadline": "2026-10-19",
        "daysToNextDeadline": 6,
        "affidavitType": "section8_10_year",
        "section8WindowOpens": "2025-10-18",
        "section8Due": "2026-10-18",
        "section8GraceEnds": "2027-04-18",
        "section8FiledOn": null,
        "renewalWindowOpens": "2025-10-18",
        "renewalDue": "2026-10-18",
        "renewalGraceEnds": "2027-04-18",
        "renewalFiledOn": null,
        "lastAcceptedFilingPeriod": "6_year",
        "lastAcceptedFilingOn": "2023-04-26",
        "mode": "check",
        "tsdrUrl": "https://tsdr.uspto.gov/#caseNumber=86530615&caseSearchType=US_APPLICATION&caseType=DEFAULT&searchType=statusSearch",
        "checkedAt": "2026-10-13T20:27:03.668Z"
    },
    {
        "status": "not-found",
        "errorCode": "not-found",
        "error": "TSDR has no status record for serial number 00000001. Check the number; a very new filing can take a few days to load. Nothing was charged.",
        "input": "00000001",
        "serialNumber": "00000001",
        "markText": null,
        "deadlineStatus": null
    }
]

Both rows are shortened here (the rule sentences, the attorney and a few codes are left out). Every row carries every field, with null where a value does not apply, so exports keep the same columns. The renewal above was due on 18 October 2026, a Sunday, so nextDeadline is Monday 19 October.

A watch row for a change carries the same fields, plus what changed:

{
    "status": "ok",
    "registrationNumber": "5065000",
    "markText": "RETHINKING AUTOMOTIVE",
    "deadlineStatus": "renewal_grace_period",
    "mode": "watch",
    "changeType": "changed",
    "changes": [{ "field": "deadlineStatus", "old": "renewal_due_within_90_days", "new": "renewal_grace_period" }],
    "newEvents": [],
    "stateStore": "my-portfolio-watch"
}

Tips for faster runs and lower costs

• Start a portfolio with a watch, not a check. The first watch run delivers every mark in full, so a separate check first means paying for the same marks twice.
• Schedule a watch weekly. Statuses move over weeks and maintenance deadlines over months, and a weekly run reports every change within seven days. A daily run reads every mark every day for the same changes.
• Set stateStoreName for a list you will edit. Without it, any change to the list starts a new memory, and the next run delivers and charges every mark as a baseline again.
• Turn off Include goods and services text when you do not need the wording. Rows get much smaller and exports easier to read.
• A run reads about one mark a second, so 500 marks take about 9 minutes. Give long lists a run timeout of 15 minutes or more. A run that reaches its limit lists the marks it did not reach in one free skipped row, and a watch reads them next time.

FAQ, disclaimers and support

Where does the data come from, and may I use it?

From USPTO's TSDR API, the same records the TSDR website shows. Trademark records are public, and the data USPTO publishes is generally not protected by copyright as a work of the US government. Marks themselves are other people's trademarks, and the record does not let you use them. How you may use what you collect depends on your purpose and your country, so check that for your use case. This is general information, not legal advice.

Is this an official USPTO tool?

No. The Actor is an independent tool, not affiliated with, made, endorsed or checked by USPTO. The data comes as TSDR holds it on the day of the run: a filing made today can take some days to appear, and until then the row shows the state before it. Check the mark's TSDR page (the tsdrUrl column) before you act on a row.

Is this legal advice, and can I file by these deadlines?

No. The deadlines are computed by the Actor from the registration date and the prosecution history, never read from USPTO, and they must be checked against the record and the rules before anything is filed. Missing a maintenance deadline can cost a registration. Ask a trademark attorney when it matters.

How are the deadlines computed, and where can they be wrong?

The rules, each named in the row's section8Rule and renewalRule:

• Section 8 declaration (37 CFR 2.160). Due in the year before the 6th anniversary of the registration date, then in the year before every 10th anniversary. A 6-month grace period follows, with a surcharge.
• Section 9 renewal (37 CFR 2.182). Due in the year before the registration expires, every 10 years from the registration date, with the same 6-month grace period. It is filed together with the 10-year Section 8 declaration.
• Madrid registrations (37 CFR 7.36). A registration under Section 66(a) files a Section 71 declaration on the same schedule instead of Section 8, and renews at WIPO, so its renewal fields are empty.
• Weekends and holidays (37 CFR 2.196). When a due date or the end of a grace period falls on a Saturday, Sunday or a federal holiday in Washington DC, the last day is the next business day. nextDeadline, daysToNextDeadline and deadlineStatus use that day; section8Due, section8GraceEnds, renewalDue and renewalGraceEnds keep the anniversary itself.
• Filed or not. A filing counts for a period when the prosecution history shows it between the window opening and the end of the grace period. An acceptance moves the mark to its next period.

Where the result can be wrong:

• A filing described in words the Actor does not know. Filings and acceptances are recognised from USPTO's entry codes and descriptions. A filing recorded in an unusual way could be missed, and the row would then show a grace period or grace_period_ended for a mark that was filed. Check section8FiledOn, lastEventDescription and the TSDR page.
• Records that lag. A declaration filed in the last few days may not be in TSDR yet.
• Unplanned closures. The holiday list covers the federal holidays in law, including Inauguration Day. A day the Office closes at short notice, such as for weather, is not known to the Actor.
• 29 February. A registration dated 29 February has its anniversaries counted on 28 February in years that have no 29th.
• Old registrations. Registrations from before the 1946 Act, and those with 20-year terms from before 1989, are computed on the 10-year schedule, which every one of them still live today follows. Their first declarations, all long past, are not modelled.
• Only maintenance deadlines. The Actor computes Section 8, 9 and 71 deadlines only. Deadlines in a pending application, such as the response to an office action or a statement of use, are not computed; such a mark shows not_registered, and its latest event tells you what happened last.
• Who owns the mark. The owner shown is the newest owner group in the record. An assignment that is not recorded at USPTO does not show.

Is personal data involved?

Some owners are individuals, and the record names attorneys. The Actor keeps owner and attorney names as the public record shows them, because the name is what identifies a mark's owner. It drops every email address, phone number and street address it reads, and for an individual owner it keeps only the country, not the state or the city. Under the GDPR and similar laws you are the controller of what you collect, so keep and use it for a lawful reason.

If a row is about you and you want it out of this Actor's output, open an issue on the Issues tab with the serial number. The mark is then left out of all future output: a run returns a free removed row in its place. The record stays on TSDR, which only USPTO can change.

How does the Actor know what changed, and how do I start over?

After each run it keeps the last delivered state of each mark (status code and date, registration number, owner, attorney, the newest prosecution entry and the deadline status) in a named key-value store, listed in each row as stateStore. The next run compares each mark with it, and delivers a mark only when one of those differs or a new prosecution entry appeared. To start over, delete that store under Storage in Console, or set a new stateStoreName. Not-found and failed marks are never stored, so they are tried again on every run.

What happens when TSDR limits the requests?

USPTO allows 60 requests a minute per key. The Actor sends one a second. A "too many requests" answer (HTTP 429) is waited out for as long as its Retry-After header says, or 60 seconds, and three in a row stop the run. The marks it did not reach get one free skipped row with the code rate-limited, and a watch reads them next time. On the built-in key the limit is shared by every user of the Actor, which is one more reason to add your own key.

What happens when TSDR refuses the key?

The run stops at the first refusal, charges nothing, and ends as Failed with a message that says which key was refused (yours or the built-in one) and what to do. A 401 or 403 answer is never retried. A key TSDR does not know gets the same 404 as a missing mark, so before calling a mark missing the Actor reads one well known registration once to see whether the key works.

What happens when a run reaches its time limit?

The Actor reads the time limit of the run from the platform and starts no new mark in the last 30 seconds. What it did not reach gets one free skipped row with the code run-time-limit, and a watch reads those marks next time.

What if something looks wrong?

Open the Issues tab on the Actor page and describe your input and what you expected. A run link helps. Issues are answered within two days.

Other Actors by the same developer

• UK Company Check: Companies House status, outstanding charges and risk flags for UK companies, or a list of newly registered ones.
• SEC Form D Feed: new private fundraising rounds filed with the SEC on Form D, with amounts and industry.
• SEC EDGAR Filing Monitor: new SEC filings for the tickers or CIKs you watch.
• SEC XBRL Fundamentals: revenue, EPS, cash flow and other reported figures per company and period, from SEC XBRL filings.
• New Scholarly Papers Watch: papers new since your last run for the keywords, ORCID authors, journals, funders or DOIs you watch, from Crossref.
• Full Page Website Screenshot: full-page PNG or JPEG screenshots, including pages that load content as you scroll.