# IPOS Patent Status Review (`remarkable_whipscorpion/ipos-patent-status-review`) Actor

Review published administrative status for up to 20 exact Singapore patent application numbers, with explicit unknowns and optional prior-fact comparisons.

- **URL**: https://apify.com/remarkable_whipscorpion/ipos-patent-status-review.md
- **Developed by:** [Kagerou AP](https://apify.com/remarkable_whipscorpion) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## IPOS Patent Status Review

Look up published administrative status for up to 20 exact Singapore patent application numbers. The result is a small JSON batch for an IP portfolio data integrator's human docket reconciliation, with optional comparisons to previously observed facts.

### Input

The prefilled form, omitted-field defaults, and API example use the same real source number. `examples/input.json` is the run payload; `examples/api-example.json` supplies the documented [Update Actor API](https://docs.apify.com/api/v2/actor-put) `exampleRunInput` body and content type for the separately authorized native handoff. That metadata file does not apply a platform update by itself.

```json
{
  "applicationNumbers": ["11202308403S"],
  "previousFacts": []
}
```

`applicationNumbers` accepts 1–20 known identifiers, each consisting of 1–32 letters or digits. Matching preserves case. Duplicate numbers produce one lookup and at most one custom charge. `previousFacts` is optional and accepts up to 20 objects with `applicationNumber` and at least one of `sourceStatus` or `sourceLastModifiedDate`; only numbers in the request are accepted, and duplicate prior identities are rejected. A prior fact is a nonempty raw string or `null` for unknown.

```json
{
  "applicationNumbers": ["11202308403S"],
  "previousFacts": [
    {
      "applicationNumber": "11202308403S",
      "sourceStatus": "Pending (Published)",
      "sourceLastModifiedDate": "2026-07-23"
    }
  ]
}
```

The prior strings above illustrate the structure using the recorded source observation of 12 October 2026; they are not promised current values.

### Results and coverage

The default Dataset contains one row per unique requested number, including diagnostic rows. The default key-value store's `REPORT` contains the same saved rows plus coverage, billing, source attribution, licence and scope. The Actor Output tab links to both stores.

| Field | Meaning |
| --- | --- |
| `applicationNumber` | The exact requested identifier. |
| `sourceStatus` | Raw published `applicationStatus`, or `null` when unknown or excluded by budget. |
| `sourceLastModifiedDate` | Raw case `lastModifiedDate`, or `null`; no legal date interpretation. |
| `observedAt` | UTC observation time and source access date. |
| `comparison` | `baseline_only`, `changed`, `unchanged`, or `unknown`. |
| `changedFields` | Mutually observed fields whose raw prior and current strings differ. |
| `sourceDatasetUrl` | Official dataset attribution link. |
| `sourceDatasetRefreshTimeIfObserved` | A dataset refresh time only if directly observed; otherwise `null`. |
| `scope` | Administrative facts for human review. |
| `unknownReason` | The reason for missing, ambiguous, failed, partial, unprocessed, or budget-excluded facts; otherwise `null`. |

`baseline_only` establishes the current observed baseline when no prior facts are supplied. Comparisons use only fields with nonempty values in both the supplied prior record and the current source record. Missing fields remain unknown, and partially observed cases do not claim a complete unchanged comparison. A case with a useful status but a missing source date can still be a billable status observation. A dataset refresh timestamp is never substituted for a case's `lastModifiedDate`.

The recorded official-source probe at **2026-10-12T13:43:39.791Z** returned one exact `11202308403S` row with `applicationStatus: "Pending (Published)"` and `lastModifiedDate: "2026-07-23"`. The same live lookup is used at run time, so later status and date values may differ. It does not return a fixed demo row.

The following illustrates that recorded source observation in the output format. It is an explanatory sample, not evidence of a cloud Actor run or a settled charge:

```json
{
  "applicationNumber": "11202308403S",
  "sourceStatus": "Pending (Published)",
  "sourceLastModifiedDate": "2026-07-23",
  "observedAt": "2026-10-12T13:43:39.791Z",
  "comparison": "baseline_only",
  "changedFields": [],
  "sourceDatasetUrl": "https://data.gov.sg/datasets/d_cb395225d1dcf91cc795f83e572c5e0e/view",
  "sourceDatasetRefreshTimeIfObserved": null,
  "scope": "Published IPOS administrative facts for human review; no legal rights, validity, deadlines or renewal advice.",
  "unknownReason": null
}
```

`REPORT.coverage` distinguishes `requestedCases`, `uniqueCases`, `sourceCalls`, `observedCases`, `unknownCases`, `unprocessedCases`, `eligibleCases`, `savedEligibleCases`, `budgetExcludedCases`, and `stopReason`. Read those counts with the individual `unknownReason` values. A missing exact row, multiple rows, a failed request, a size or time limit, and a number skipped after a stop are unknowns. They never mean there is no patent, that rights ended, or that nothing changed.

### Price and budget

The proposed Pay-per-event custom price is **$0.02 USD** for `patent_status_observed`: one unique exact case with a useful published administrative status saved to the outputs. An unchanged status is still a new observed snapshot. Missing, ambiguous, all-unknown, invalid, failed and diagnostic-only cases incur **0 custom events**. Dataset rows have no additional item charge.

An automatic platform startup charge of **$0.00005 USD** is separate. Zero custom events does not mean zero total charge. Reserve startup cost in the run budget: $0.02005 funds one custom observation plus startup, and $0.40005 funds at most 20 custom observations plus startup. Prices are a local release proposal until platform pricing is separately configured and verified.

The Actor determines funded useful capacity before saving useful content to any Dataset, key-value report or checkpoint. It persists the funded results before requesting the corresponding exact event count. If budget cannot fund a useful case, its saved row withholds the status and source date and records `unknownReason: "budget_excluded"`. `REPORT.billing` records the event name, unit price, settled units, whether the charge count is exact, and custom-charge status. An uncertain prior charge stops safely instead of blindly charging again.

### Source, limits and attribution

Source: **Intellectual Property Office of Singapore (IPOS), published via [data.gov.sg's IPOS patent dataset](https://data.gov.sg/datasets/d_cb395225d1dcf91cc795f83e572c5e0e/view)**. Selected factual data is used under the [Singapore Open Data Licence](https://data.gov.sg/open-data-licence). Documentation source access date: **12 October 2026**; every result carries its own access time in `observedAt`. The data has been projected to the three needed source fields and converted into a review row. **This Actor is not endorsed by IPOS or the Singapore Government.** The licence does not confer patent rights or rights to excluded personal or third-party material.

The Actor uses the official anonymous Datastore Search API with exact filters, the three-field projection `applicationNumber,applicationStatus,lastModifiedDate`, and a two-row limit to detect ambiguity. It makes at most one request per unique case, with requests at least 3.1 seconds apart, a 20-second HTTP timeout, a 200,000-byte response cap, and a 100-second internal runtime cap. The proposed default platform run timeout is 110 seconds with 256 MB memory; those API run options require the native handoff to be applied and verified.

The [documented anonymous Datastore Search limit](https://guide.data.gov.sg/developer-guide/api-overview/api-rate-limits) is four requests per ten seconds. A 429 response stops further source requests in that run without retries and preserves explicit partial coverage. The [API guide](https://guide.data.gov.sg/developer-guide/api-overview) strongly recommends a production key; the current small anonymous scope uses no source key, browser, proxy or login.

**Shared egress limits across simultaneous runs remain unresolved.** Per-run spacing does not coordinate requests from other runs sharing an IP address. The documented [Apify account concurrency limits](https://docs.apify.com/account/limits) are per user, and the [Actor API's standby request limits](https://docs.apify.com/api/v2/actor-put) regulate request routing within standby runs. Neither establishes a cross-run source rate limit for this Actor. Scaling beyond the controlled small anonymous experiment is on hold until aggregate source access can be bounded; unlimited concurrent use is not promised.

This output supports a human review of published administrative facts. It does not include applicant, inventor or agent identities, addresses, claims, documents, ownership, patent-rights validity, legal deadlines, renewal instructions or payments. Source completeness and the legal meaning of a status are not guaranteed by this dataset. Use the authoritative legal register and a qualified professional when those questions are part of the job.

### Local release state

This package is prepared for local implementation and independent review. Actor creation, push, cloud build, paid run, pricing activation and publication require separate manager approval. A local schema or test result alone does not establish a recognized cloud Output schema, a settled live charge, source access from Apify's cloud, or a public listing.

# Actor input Schema

## `applicationNumbers` (type: `array`):

One to 20 known application numbers, each 1–32 letters or digits. Case is preserved. Repeated numbers are looked up and billed once. Omitted input uses the same live-source example as the prefilled form.

## `previousFacts` (type: `array`):

Up to 20 prior facts for numbers in this request. Each number may occur once and must contain sourceStatus or sourceLastModifiedDate. Supply the raw prior strings or null; null means unknown. Only fields present and nonempty on both sides are compared. Missing fields and absent records never imply a legal change.

## Actor input object example

```json
{
  "applicationNumbers": [
    "11202308403S"
  ],
  "previousFacts": []
}
```

# Actor output Schema

## `observations` (type: `string`):

Default Dataset contains the ten documented factual and comparison fields per unique requested application number. Null status and unknownReason distinguish unavailable or budget-excluded facts.

## `report` (type: `string`):

REPORT contains the same saved rows, coverage counts and stopReason, exact settled custom-event count, source attribution and licence. Inspect it before treating a partial run as complete.

# 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 = {
    "applicationNumbers": [
        "11202308403S"
    ],
    "previousFacts": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("remarkable_whipscorpion/ipos-patent-status-review").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 = {
    "applicationNumbers": ["11202308403S"],
    "previousFacts": [],
}

# Run the Actor and wait for it to finish
run = client.actor("remarkable_whipscorpion/ipos-patent-status-review").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 '{
  "applicationNumbers": [
    "11202308403S"
  ],
  "previousFacts": []
}' |
apify call remarkable_whipscorpion/ipos-patent-status-review --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,remarkable_whipscorpion/ipos-patent-status-review"
        }
    }
}
```

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/td7TPO0KAA7HQLUbq/builds/uefQQm693sNo24yof/openapi.json