# Corporate & Patent Intelligence - PTAB, EPO, Registers (`stefano_seggio/global-corporate-patent-intelligence`) Actor

Patent disputes and company registers in one Actor: USPTO PTAB trials and EPO opposition watch (your own API keys), ClinicalTrials.gov and FDA Orange Book, Singapore ACRA and the UAE ADGM register. Receive only new or changed records.

- **URL**: https://apify.com/stefano_seggio/global-corporate-patent-intelligence.md
- **Developed by:** [Stefano Seggio](https://apify.com/stefano_seggio) (community)
- **Categories:** Business
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 patent enforcement proceedings

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

## Global Corporate & Patent Intelligence

One Actor, four public sources for patent disputes, clinical-trial and drug-patent data, and the Singapore company register. Pick the sources for each run and receive only the records that are **new or changed since your last run**, as clean JSON in the dataset.

Typical users: IP and litigation teams watching patent disputes, pharma competitive-intelligence analysts, KYC and onboarding teams that need register changes, and market researchers.

### What is covered

| Source id | What it reads | Scope to know before you rely on it |
|---|---|---|
| `uspto_ptab` | USPTO Patent Trial and Appeal Board trial proceedings (IPR, PGR, CBM, DER) through the USPTO Open Data Portal, newest petition first | **Bring your own key:** needs your USPTO Open Data Portal API key (`usptoOdpApiKey`). |
| `epo_opposition` | EPO Open Patent Services legal-status lookup, reporting opposition-family legal events | **Watchlist-driven.** You supply the EP publication numbers to look up (`epWatchlist` in `sourceOptions`); the Actor does not search for all oppositions. An empty or invalid list fails preflight. **Bring your own keys:** `epoOpsConsumerKey` and `epoOpsConsumerSecret`. |
| `clinicaltrials_orange_book` | ClinicalTrials.gov v2 studies (newest update first) and FDA Orange Book products with patent and exclusivity data (openFDA) | Choose `clinicaltrials`, `orange_book` or both through `subSources`. Optional filters include sponsors, keywords and condition. An optional openFDA API key raises openFDA's limits. |
| `sg_acra` | Singapore ACRA register of corporate entities from data.gov.sg (monthly extract in 27 first-letter shards), newest registrations first | The default shard is `A` only; list the shards you need in `shardSelection`. Optional `ssicCodeFilter` and `entityStatusFilter`. Released under the Singapore Open Data Licence. |

**Not available (held):** `ae_registers` (ADGM's register service has answered every search with a server error, `System.NullPointerException` in `RASearchUtil.getSearchResponseForPR`, since at least 2026-09-17, from Apify's cloud and from elsewhere, and no row has ever been obtained; the DIFC register is disallowed by the site's robots.txt and Dubai mainland licences need an approval). A held source cannot be selected: the input form does not list it, and the platform rejects an API call that names one as invalid input before a run starts, so nothing is charged. Should one ever reach the Actor, the run stops before any request to a source is made and before any record is billed; the platform still charges the start event of a run that has started.

### How to use it

1. Open the **Input** tab and choose one or more `sources`. Start with one. The form is prefilled with a small snapshot (`deltaMode: "all"`, 10 records per source) so that the first run shows data at once; for a scheduled Task set `deltaMode` to `onlyChanged` and raise `maxItemsPerSource`.
2. Add the credentials the source needs (see "Credentials").
3. Run it. The first run of a source treats every record it reads as new (see "Control your spend" below).
4. Put the same input in a **Task** and attach an Apify **Schedule**. Each Task keeps its own delta memory, so later runs deliver only what changed.
5. Read the results from the dataset, the Apify API, or an Apify webhook/integration.

Example input:

```json
{
  "sources": ["clinicaltrials_orange_book"],
  "sourceOptions": {
    "clinicaltrials_orange_book": { "sponsors": ["Pfizer"] }
  },
  "deltaMode": "onlyChanged",
  "maxItemsPerSource": 200,
  "watchlistNames": ["Pfizer"]
}
```

Each source validates its own slice of `sourceOptions` and rejects unknown keys, so a typo fails the run in preflight instead of being ignored.

### Delta modes

| `deltaMode` | Delivers |
|---|---|
| `onlyChanged` (default) | Records seen for the first time, and records whose content or status changed |
| `onlyNew` | Records seen for the first time |
| `all` | Every record, unchanged ones included (tagged `delta_status: "unchanged"`) |

Delta memory is kept per `stateNamespace` (default: one per Task) in a key-value store named `global-corporate-patent-intelligence-delta-state` in your account. Give two Tasks that run at the same time different namespaces: a second concurrent run of the same namespace and source is refused. A run that is killed (timeout, abort, out of memory) cannot release its lease, so a restart on the same namespace is refused until 15 minutes after that run's last heartbeat (the refused run still pays the start event); a new namespace would start from an empty memory and deliver, and bill, everything again. To restart a source from scratch, delete its `state.<namespace>.<source>` and `journal.<namespace>.<source>` records.

### Output

Every dataset row carries `engine`, `source`, `record_id`, `delta_status`, `is_new`, `is_watchlist_match`, `matched_watchlist_keyword` and `scraped_at`, plus the fields of the source. A `RUN_SUMMARY` record in the key-value store lists per-source counts, warnings and watchlist accounting.

A run ends `FAILED` when preflight finds a problem (an unknown or held source, a missing credential, an invalid option) before any request, or when every selected source failed and nothing was delivered. If at least one source answered, the run succeeds and the per-source errors stay on `RUN_SUMMARY`: check it in automated pipelines.

### Watchlist

`watchlistNames` is a list of keywords matched case-insensitively as substrings against each record's names (parties, sponsors, entity names and similar). Entries shorter than three characters (letters or digits, not counting punctuation), blank or punctuation-only entries are ignored; with no valid keyword nothing matches. A matching record is flagged `is_watchlist_match` and billed a **Watchlist hit** event on top of its row event. Two hard ceilings apply per run: `maxWatchlistHitsPerRun` (default 200) and `maxWatchlistSpendUsd` (default 50). Use broad keywords with care.

### Pricing

This Actor uses pay-per-event pricing. The **Pricing** tab shows the current price of every event; prices are deliberately not repeated on this page so that it cannot go out of date.

- **Actor start**: charged per GB of memory the run is configured with. This Actor uses 1 GB, so each run starts one start event.
- **One row event per delivered record**, named by source: Patent enforcement proceeding (`uspto_ptab` and `epo_opposition`); Clinical trial / Orange Book record (`clinicaltrials_orange_book`); New Singapore ACRA entity and Updated Singapore ACRA entity (`sg_acra`).
- **Watchlist hit**: see above.

With `deltaMode: "all"` every delivered record is billed, unchanged ones at the source's "Updated" event (or its only row event). Records that are not delivered are not billed a row event. Your own API keys are used against the publishers' services; any fees or limits on those keys are between you and the publisher.

#### Control your spend

- The first run of a source delivers up to `maxItemsPerSource` records (default 500, range 1 to 10,000) and bills each one. Registers can be large; for a trial set a low value such as 20.
- Use Apify's maximum-cost-per-run setting as an additional ceiling. When the limit is reached the run stops cleanly and `RUN_SUMMARY` says so (`stoppedOnChargeLimit`). The platform refuses a limit below the start event plus the most expensive single event of the Actor and names the minimum in its error.
- Keep `deltaMode` at `onlyChanged` for scheduled runs.

### Reliability notes

Delivery is at-least-once: a progress checkpoint is written every 25 rows and a small journal after every row that was delivered and billed, so after a hard kill at most the one record in flight can be delivered and billed again. A memory record that exists but cannot be read fails its own source instead of being treated as empty.

### Credentials

| Field | Used by |
|---|---|
| `usptoOdpApiKey` | `uspto_ptab` |
| `epoOpsConsumerKey`, `epoOpsConsumerSecret` | `epo_opposition` |
| `fdaApiKey` (optional) | `clinicaltrials_orange_book` |

All are stored encrypted by Apify and never logged. A source whose required credential is missing fails preflight before any request to a source and before any record is billed (the start event of the run is still charged).

### Data sources and licences

Records are published by the USPTO, the European Patent Office, ClinicalTrials.gov (US National Library of Medicine), the US FDA (openFDA) and the Singapore Government's data.gov.sg (Singapore Open Data Licence). Reuse terms are those of each publisher: check them for your use case.

### Disclaimer

This Actor reads public sources and reports what they publish. It is not legal, medical or investment advice. Patent legal-status and register data can lag or be corrected upstream: confirm deadlines and statuses on the official register before you rely on them.

### Support

Questions and bug reports: the **Issues** tab of this Actor (https://apify.com/stefano_seggio/global-corporate-patent-intelligence/issues/open).

# Actor input Schema

## `sources` (type: `array`):

Source ids to run in this execution. Held sources are not selectable: ae_registers.

## `sourceOptions` (type: `object`):

Options keyed by source id, e.g. {"clinicaltrials_orange_book": {"sponsors": \["Pfizer"]}}. Each source validates its own slice and rejects unknown keys. Put credentials in the secret fields below, not here.

## `deltaMode` (type: `string`):

onlyChanged = new and changed records (default). onlyNew = new records only. all = every record, unchanged ones included.

## `stateNamespace` (type: `string`):

Keeps delta memory separate between Tasks (different watchlists, filters or delta modes would otherwise consume each other's "new" records). Leave empty to use one namespace per Task, or "default" for ad-hoc runs. 1-40 characters: a-z, 0-9, "-".

## `maxItemsPerSource` (type: `integer`):

Upper bound on records taken from each source in one run.

## `watchlistNames` (type: `array`):

Case-insensitive substrings matched against each record's names. Entries shorter than 3 characters, blank or punctuation-only entries are ignored. With no valid keyword nothing matches and the watchlist-hit event is never charged.

## `maxWatchlistHitsPerRun` (type: `integer`):

Hard ceiling on watchlist-hit events charged in one run.

## `maxWatchlistSpendUsd` (type: `number`):

Hard ceiling on USD charged for watchlist-hit in one run.

## `usptoOdpApiKey` (type: `string`):

Bring-your-own credential for uspto_ptab. Stored encrypted by Apify and never logged.

## `epoOpsConsumerKey` (type: `string`):

Bring-your-own credential for epo_opposition. Stored encrypted by Apify and never logged.

## `epoOpsConsumerSecret` (type: `string`):

Bring-your-own credential for epo_opposition. Stored encrypted by Apify and never logged.

## `fdaApiKey` (type: `string`):

Bring-your-own credential for clinicaltrials_orange_book. Stored encrypted by Apify and never logged.

## Actor input object example

```json
{
  "sources": [
    "clinicaltrials_orange_book"
  ],
  "sourceOptions": {},
  "deltaMode": "all",
  "maxItemsPerSource": 10,
  "watchlistNames": [],
  "maxWatchlistHitsPerRun": 200,
  "maxWatchlistSpendUsd": 50
}
```

# Actor output Schema

## `records` (type: `string`):

One dataset row per delivered record: engine, source, record_id, delta_status, is_new, is_watchlist_match, matched_watchlist_keyword and scraped_at, plus the fields of the source.

## `runSummary` (type: `string`):

Per-source counts, warnings and watchlist accounting of this run (the RUN_SUMMARY record of the default key-value store).

# 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 = {
    "sources": [
        "clinicaltrials_orange_book"
    ],
    "deltaMode": "all",
    "maxItemsPerSource": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("stefano_seggio/global-corporate-patent-intelligence").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 = {
    "sources": ["clinicaltrials_orange_book"],
    "deltaMode": "all",
    "maxItemsPerSource": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("stefano_seggio/global-corporate-patent-intelligence").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 '{
  "sources": [
    "clinicaltrials_orange_book"
  ],
  "deltaMode": "all",
  "maxItemsPerSource": 10
}' |
apify call stefano_seggio/global-corporate-patent-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,stefano_seggio/global-corporate-patent-intelligence"
        }
    }
}
```

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/0DEMn8JAgSZXEaFQ4/builds/VVHQ6B8fjNqe14FOQ/openapi.json