# USPTO TTAB Proceedings Search (`automation-lab/uspto-ttab-proceedings-search`) Actor

Search and export public USPTO TTAB opposition, cancellation, concurrent-use, and appeal proceedings with parties, marks, filings, dates, deadlines, and source links.

- **URL**: https://apify.com/automation-lab/uspto-ttab-proceedings-search.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.78 / 1,000 ttab proceedings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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 TTAB Proceedings Search

Search and export public USPTO Trademark Trial and Appeal Board (TTAB) proceedings from TTABVUE. Turn opposition, cancellation, concurrent-use, and appeal files into structured records containing proceeding identifiers, parties, marks, statuses, dates, filing rows, due dates, and official source links.

Use this Actor for one-time trademark-dispute research or schedule it to monitor a known proceeding, party, mark, application, or registration. It uses the public USPTO gov database and requires no USPTO login or API key.

### What does this USPTO TTAB scraper do?

The Actor supports two complementary workflows:

1. Look up exact 8-digit TTAB proceeding numbers or official TTABVUE URLs.
2. Search TTABVUE by words, mark, party, second party, application number, or registration number.

Search results are resolved to their official detail pages. Every accepted proceeding becomes one dataset item. Explicit lookups and discovered results pass through the same status and proceeding-type filters.

The Actor can include the complete prosecution-history table in each item. Those filing rows preserve the source sequence number, filing date, history text, due date when present, and official TTABVUE document link.

### Who is it for?

- **Trademark attorneys and paralegals** researching opposition and cancellation dockets.
- **Brand protection teams** monitoring disputes involving portfolio marks or counterparties.
- **IP operations teams** feeding proceeding changes into review queues and dashboards.
- **Researchers and analysts** building reproducible USPTO data exports.
- **Developers and AI agents** that need typed JSON instead of legacy TTABVUE HTML.

This Actor returns public proceeding records. It does not provide legal advice, predict outcomes, or replace docket review by qualified counsel.

### Why use this Actor?

- Search and exact proceeding lookup in one input contract.
- One normalized row per proceeding, suitable for JSON, CSV, Excel, and APIs.
- Parties retain their source roles, such as Plaintiff and Defendant.
- Marks retain serial number, registration number, application status, role, and TSDR link.
- Filing history includes source document links and recorded due dates.
- Direct HTTP extraction keeps runs lightweight; no browser or proxy is enabled.
- Stable `proceedingNumber` and `sourceUrl` fields make recurring-run comparisons practical.

### What USPTO data is extracted?

| Field | Meaning |
| --- | --- |
| `proceedingNumber` | Stable 8-digit TTAB proceeding identifier |
| `proceedingType` | Source type, such as Opposition or Cancellation |
| `status` | Current TTABVUE proceeding status |
| `filingDate` | Proceeding filing date shown by TTABVUE |
| `statusDate` | Date associated with the current status |
| `interlocutoryAttorney` | Assigned attorney when listed |
| `paralegal` | Assigned paralegal when listed |
| `parties` | Party role, name, and public correspondence block |
| `marks` | Mark text, role, serial/registration identifiers, status, and TSDR link |
| `filings` | Prosecution-history sequence, date, text, due date, and document URL |
| `nextDeadline` | Earliest future due date found in returned filing rows |
| `sourceUrl` | Official TTABVUE proceeding page |
| `retrievedAt` | UTC retrieval timestamp |

Some historical records omit optional assignments, registrations, correspondence, or due dates. Empty source fields are not invented.

### Getting started

1. Open the Actor input page.
2. Keep the prefilled proceeding `91290000`, or replace it with your own 8-digit numbers.
3. Alternatively, clear `proceedingNumbers` and fill one or more search fields.
4. Choose `Pending`, `Terminated`, or `All` for proceeding status.
5. Leave **Include prosecution history** enabled when you need filings and deadlines.
6. Set a practical maximum number of proceedings.
7. Start the run and open the **TTAB proceedings** dataset view.
8. Export the dataset as JSON, CSV, Excel, XML, or RSS, or consume it through the API.

### Input parameters

#### Exact lookup

- `proceedingNumbers`: one or more exact 8-digit Board proceeding numbers.
- `startUrls`: official `ttabvue.uspto.gov/ttabvue/v?pno=...` detail URLs.

#### Search

- `searchTerms`: words matched across identifiers, parties, and marks by TTABVUE.
- `mark`: words that must occur in the mark.
- `party`: words that must occur in one party name.
- `otherParty`: optional second party; useful for disputes between two known organizations.
- `applicationOrRegistrationNumber`: a USPTO serial, registration, expungement, or reexamination number.

#### Filters and output controls

- `status`: `All`, `Pending`, or `Terminated`; defaults to `All`.
- `proceedingTypes`: optional text filters such as `Opposition`, `Cancellation`, or `Appeal`.
- `includeFilings`: include prosecution-history rows; defaults to `true`.
- `maxItems`: stop after 1–1,000 accepted proceedings; defaults to 20.

Provide at least one exact lookup or search field. Proceeding numbers must contain exactly eight digits. Unsupported hosts and malformed TTABVUE URLs fail before extraction.

### Search examples

Find pending proceedings involving Apple:

```json
{
  "proceedingNumbers": [],
  "party": "Apple",
  "status": "Pending",
  "includeFilings": false,
  "maxItems": 5
}
```

Extract a known opposition with its full docket:

```json
{
  "proceedingNumbers": ["91290000"],
  "includeFilings": true,
  "maxItems": 1
}
```

Find proceedings associated with a trademark serial number:

```json
{
  "proceedingNumbers": [],
  "applicationOrRegistrationNumber": "97731108",
  "status": "All",
  "includeFilings": true,
  "maxItems": 10
}
```

### Output example

A current exact lookup produces a record shaped like this (arrays shortened for readability):

```json
{
  "proceedingNumber": "91290000",
  "proceedingType": "Opposition",
  "status": "Terminated",
  "filingDate": "02/27/2024",
  "statusDate": "05/28/2024",
  "parties": [
    { "role": "Defendant", "name": "Jinqiu Feng" },
    { "role": "Plaintiff", "name": "TikTok Ltd." }
  ],
  "marks": [
    {
      "role": "Defendant",
      "mark": "TIKTUU",
      "serialNumber": "97731108",
      "applicationStatus": "ABANDONED - AFTER INTER-PARTES DECISION"
    }
  ],
  "filings": [
    { "number": "5", "date": "05/28/2024", "text": "BD DECISION: OPP SUSTAINED" }
  ],
  "sourceUrl": "https://ttabvue.uspto.gov/ttabvue/v?pno=91290000",
  "retrievedAt": "2026-08-27T20:00:00.000Z"
}
```

The full dataset keeps all returned party, mark, and filing objects. Export formats flatten or serialize nested arrays according to Apify's dataset export options.

### Monitor TTAB disputes over time

Create an Apify Task with a stable party, mark, serial number, registration number, or set of proceeding numbers. Schedule it daily or weekly. Store each run's dataset, or send results through a webhook to your database or automation platform.

For change detection, key records by `proceedingNumber` and compare `status`, `statusDate`, `nextDeadline`, and the filing `number` values against the previous run. The Actor reports the current public source state; it does not itself retain prior runs or send legal alerts.

### How much does it cost to search USPTO TTAB proceedings?

The Actor uses pay-per-event pricing: one small start charge per run plus one `item` event for each proceeding stored in the default dataset. Filing rows, parties, and marks are included inside the proceeding item and are not separately charged.

The current start event is **$0.005 per run**. Current per-proceeding prices decrease by Apify subscription tier:

| Tier | Price per proceeding |
| --- | ---: |
| Free | $0.014904 |
| Bronze | $0.01296 |
| Silver | $0.010109 |
| Gold | $0.007776 |
| Platinum | $0.005184 |
| Diamond | $0.0036288 |

Estimate a run as:

`run price = $0.005 + number of saved proceedings × your tier's item price`

At Bronze rates, 1 proceeding costs about **$0.01796**, 10 cost **$0.13460**, and 100 cost **$1.30100** including the start event. A search that discovers many source records but saves only five because of its output limit charges for five proceeding items, not for every discovered link. No item charge is emitted for rejected filters, malformed source pages, or empty searches.

### Performance and limits

TTABVUE is a public legacy USPTO system. The Actor uses conservative sequential detail requests and bounded retries rather than aggressive concurrency.

- `maxItems` is capped at 1,000 per run.
- Search result coverage is limited to the links returned by the current TTABVUE result page.
- Very broad names or words can return a source-limited result set; narrow by status, mark, or another party.
- Source dates use the display format supplied by TTABVUE.
- `nextDeadline` is populated only when a filing row contains a future due date at retrieval time.
- Filing documents remain hosted by USPTO and can change or become unavailable independently.
- No proxy fallback is enabled. Persistent source errors fail visibly instead of returning fabricated data.

### Export and integration workflows

Common workflows include:

- Export pending opposition records to an IP team's spreadsheet.
- Enrich an internal trademark portfolio by serial or registration number.
- Compare current and previous filing sequences in a database.
- Send newly observed filing rows to Slack, email, or a case-management queue through Apify webhooks.
- Feed normalized records to an AI research agent while preserving official citations.
- Combine scheduled datasets in Make, Zapier, n8n, Google Sheets, or a warehouse.

### Run with the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~uspto-ttab-proceedings-search/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"proceedingNumbers":["91290000"],"includeFilings":true,"maxItems":1}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/uspto-ttab-proceedings-search').call({
  proceedingNumbers: ['91290000'],
  includeFilings: true,
  maxItems: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run = client.actor('automation-lab/uspto-ttab-proceedings-search').call(run_input={
    'proceedingNumbers': ['91290000'],
    'includeFilings': True,
    'maxItems': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

For synchronous integrations, use the run-sync-get-dataset-items endpoint and keep the requested result count small enough for the client timeout.

### Use with Apify MCP

Add this Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/uspto-ttab-proceedings-search"
```

#### Claude Desktop, Cursor, and VS Code setup

Claude Desktop, Cursor, VS Code, and other MCP-compatible clients can use:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/uspto-ttab-proceedings-search"
    }
  }
}
```

Example prompts:

- “Find up to five pending TTAB proceedings involving Apple and summarize the parties and marks.”
- “Retrieve proceeding 91290000 with its filing history and cite every official USPTO source URL.”
- “Find TTAB records associated with serial 97731108 and list the latest status and filing row.”

MCP tool calls use your Apify account and the same Actor input, dataset, and pricing contract.

### Responsible and legal use

TTABVUE records are public government records, but their contents can include names, addresses, emails, and phone numbers submitted in legal proceedings. Use the data only for legitimate research, compliance, monitoring, or other lawful purposes.

Do not use correspondence fields for unsolicited marketing, harassment, identity abuse, or automated legal conclusions. Follow applicable privacy, professional-responsibility, records-retention, and court rules. Verify deadlines and legally significant facts against the official proceeding page and filed documents.

USPTO and TTAB are third-party government services. This Actor is not affiliated with, endorsed by, or operated by USPTO.

### Troubleshooting

#### “Provide proceedingNumbers, startUrls, or at least one search field”

Clear inputs are valid only when a real lookup or search is present. Add an exact proceeding number, TTABVUE URL, party, mark, keyword, or application/registration number.

#### “Invalid proceeding number”

Use exactly eight digits without spaces, punctuation, or a URL. Put full official URLs in `startUrls` instead.

#### The dataset is empty

Confirm the same search in TTABVUE, loosen `status` or `proceedingTypes`, and check spelling. A valid no-result source search produces no proceeding items.

#### A filing has no due date or link

TTABVUE does not attach both fields to every prosecution-history row. The Actor preserves omissions rather than guessing.

#### The source returns an HTTP or unexpected-response error

Retry later with a small input. If TTABVUE is unavailable, the Actor fails visibly so scheduled workflows do not mistake an outage for a complete empty dataset.

### FAQ

#### Does this search trademark registrations generally?

No. It searches TTAB proceedings and their associated applications or registrations. Use a dedicated trademark-search Actor for general federal trademark registration research.

#### Does it include opposition and cancellation proceedings?

Yes. It parses the proceeding type reported by TTABVUE and can filter the resulting details with `proceedingTypes`.

#### Does it include appeals?

Yes, when TTABVUE returns an appeal proceeding for the supplied identifier or search. The output preserves the source proceeding type rather than mapping it to a guessed category.

#### Can it download every filing document?

It returns the official document URL shown in each filing row. It does not download or re-host document files.

#### Can I schedule monitoring?

Yes. Save a stable input as an Apify Task, schedule recurring runs, and compare datasets by `proceedingNumber` and filing `number`.

#### Is the result legal advice?

No. It is a structured copy of public source data. Consult qualified counsel and the official docket for decisions or deadlines.

### Related Automation Lab Actors

- [USPTO Trademark Search Scraper](https://apify.com/automation-lab/uspto-trademark-search-scraper) for federal trademark registration searches outside the TTAB proceeding workflow.

Use the trademark-search Actor to identify registrations and serial numbers, then use this Actor to research associated TTAB disputes.

# Actor input Schema

## `proceedingNumbers` (type: `array`):

Exact 8-digit TTAB proceeding numbers.

## `startUrls` (type: `array`):

Exact public TTABVUE detail URLs. Filters are applied to these results too.

## `searchTerms` (type: `string`):

Words to match across proceeding numbers, applications, registrations, parties, and marks.

## `mark` (type: `string`):

Find proceedings whose trademark contains all supplied words.

## `party` (type: `string`):

Find proceedings involving a party whose name contains all supplied words.

## `otherParty` (type: `string`):

Optional second party; both party filters must match the source search.

## `applicationOrRegistrationNumber` (type: `string`):

USPTO serial, registration, expungement, or reexamination number.

## `status` (type: `string`):

Return pending, terminated, or all matching proceedings.

## `proceedingTypes` (type: `array`):

Optional detail-level filters such as Opposition, Cancellation, or Appeal.

## `includeFilings` (type: `boolean`):

Include filing rows, due dates, history text, and document links.

## `maxItems` (type: `integer`):

Maximum matching proceeding records to export.

## Actor input object example

```json
{
  "proceedingNumbers": [
    "91290000"
  ],
  "status": "All",
  "includeFilings": true,
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

TTAB proceedings with parties, marks, statuses, dates, filings, deadlines, and official source links.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/uspto-ttab-proceedings-search").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/uspto-ttab-proceedings-search").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 '{}' |
apify call automation-lab/uspto-ttab-proceedings-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/uspto-ttab-proceedings-search"
        }
    }
}

```

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 <APIFY_API_TOKEN>` 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/dVZWwIhpnNwlzz5WV/builds/FSaN23YhivWUFvE90/openapi.json