# WIPO Trademarks Scraper \[$8/1K💰] | Madrid Monitor | Patents (`ahmed_jasarevic/wipo-int-scraper`) Actor

Extract international trademark registrations and PCT patents from WIPO — mark name, status, holder, Nice classes, goods and services, IRN and gazette data — as structured JSON. Built for trademark watch, brand clearance and IP due diligence. From $1.50 per 1,000 patents, $8 per 1,000 trademarks.

- **URL**: https://apify.com/ahmed_jasarevic/wipo-int-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 trademarks

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?

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

## WIPO Trademarks & Patents Scraper

Search international trademark registrations on WIPO's Madrid Monitor and pull PCT patent publications from PATENTSCOPE — mark name, holder, legal status, Nice classes, goods & services, designations, gazette publication and direct record links — as structured JSON, from $8 per 1,000 trademark records.

**Built for:**

- Brand clearance and naming research before filing
- Trademark watch and competitor filing monitoring
- IP due diligence and portfolio intelligence
- Patent landscape and PCT gazette tracking
- Building structured trademark and patent datasets

### Find And Monitor International Trademark Registrations Without An API

WIPO publishes no public REST API for trademark search: its own FAQ states the Madrid Monitor database has "not currently" offered direct search access, and its terms disallow automated querying. This actor reads the same Madrid Monitor record surfaces and PATENTSCOPE gazette browser that WIPO serves in a normal browser session, and returns the results as clean JSON you can filter, export and schedule. No WIPO account, no browser, and no CAPTCHA in trademark mode.

### How It Works

![How the WIPO Scraper works: Madrid Monitor marks and PATENTSCOPE gazettes become trademark and patent rows with status, classes and links.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-wipo-int-scraper)

Trademarks are discovered through Madrid Monitor's public JSON query and detail endpoints, which expose every INID-coded field. PCT publications are read from the PATENTSCOPE weekly gazette browser, 200 rows per page, with optional keyword search.

Trademark rows carry mark name, IRN, holder, status, dates, Nice classes, goods and services, designations and gazette data. Patent rows carry publication number, title, applicant, IPC, kind and gazette date.

Both sources are plain HTTP and parse with Cheerio — no browser, no Playwright:

1. **Trademark discovery** — `www3.wipo.int/madrid/monitor/api/v1/query/en/<term>` returns the top-name matches for a brand term, an international registration number (IRN) or a Madrid record ID.
2. **Trademark records** — `www3.wipo.int/madrid/monitor/api/v1/details/<record>?lang=en` returns the full registration, with every field marked by its INID code (holder, representative, Nice classes, goods & services, designations, basic application/registration, gazette).
3. **Patent gazettes** — the PATENTSCOPE "Browse by Week" PCT gazette browser, including its PrimeFaces JSF AJAX pagination, gives 200 rows per gazette page (publication number, title, applicant, IPC, kind, application number, gazette date).
4. **Patent keyword search (optional)** — the PATENTSCOPE simple-search page, which may show reCAPTCHA on flagged IP addresses.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `query` | array | No\* | `["NIKE"]` | Brand names, or an IRN (`652471`), a Madrid record ID (`WO50000652471`) or a full Madrid Monitor record URL. Multiple entries are searched independently. |
| `applicantName` | array | No | `[]` | Filter fetched trademark records by holder/owner name (case-insensitive substring, OR-ed). |
| `statuses` | array | No | `[]` | Filter by legal status, e.g. `Active`, `Ended`, `Pending`. |
| `niceClasses` | array | No | `[]` | Filter by Nice class numbers (1–45), e.g. `9`, `25`, `35`, `42`. |
| `maxResultsPerQuery` | integer | No | `10` | Top Madrid Monitor matches to read per query entry (max 25; the public lookup returns about 10 per term). |
| `maxResults` | integer | No | `200` | Hard cap on records stored in the dataset across trademarks and patents. |
| `gazettes` | array | No | `[]` | PCT gazette issues in `NN/YYYY` form, e.g. `42/2026`. |
| `latestGazettes` | integer | No | `0` | Scrape the N most recent PCT gazettes instead of explicit numbers (0–60). |
| `patentQueries` | array | No | `[]` | Optional PATENTSCOPE keyword searches (residential proxy recommended). |
| `patentSearchField` | string | No | `FP` | PATENTSCOPE field for keyword queries (`FP`, `EN_ALL`, `EN_ALLTXT`, `EN_CL`, `ALLNUM`, `CLASSIF`, `ALLNAMES`, `DP`). |
| `maxPagesPerGazette` | integer | No | `5` | 200-row pages fetched per gazette (a large gazette holds several thousand publications). |
| `maxRequestsPerCrawl` | integer | No | `25` | Safety cap on total HTTP requests. |
| `proxyConfig` | object | No | off | Standard Apify proxy picker. Trademark mode works without a proxy. |

\* A run with only `query` scrapes trademarks; a run with only `gazettes`/`latestGazettes` scrapes patents; an entirely empty input scrapes the latest PCT gazette.

### Output Fields

| Group | Fields |
| --- | --- |
| Identity | `recordType`, `source`, `irn`, `internationalRegistrationNumber`, `markName`, `detailUrl`, `scrapedAt` |
| Legal status & dates | `status`, `statusCode`, `registrationDate`, `expirationDate`, `publicationDate`, `publicationText` |
| Owner & representation | `holder`, `holderCountry`, `representative` |
| Classification | `niceClasses`, `goodsAndServices` (per-class text), `inidFields` (every INID-coded field) |
| Scope | `designations`, `basicApplication`, `basicRegistration`, `logoUrl` |
| Gazette | `gazetteNumber`, `gazetteDate`, `publicationNumber`, `publicationNumberNormalized` |
| Patent | `title`, `kind`, `applicationNumber`, `ipc`, `ipcCodes`, `applicant`, `docId` |

**Views:** the Output tab has separate **Trademarks** and **Patents** tables.

### Example Input

```json
{
  "query": ["NIKE", "louis vuitton"],
  "statuses": ["Active"],
  "niceClasses": ["25"],
  "maxResultsPerQuery": 10,
  "maxResults": 30
}
```

Patent run:

```json
{ "latestGazettes": 1, "maxPagesPerGazette": 5, "maxResults": 200 }
```

### Example Output

```json
{
  "recordType": "trademark",
  "source": "WIPO Madrid Monitor",
  "irn": "652471",
  "internationalRegistrationNumber": "WO50000652471",
  "markName": "NIKE",
  "status": "Active",
  "registrationDate": "1996-04-16",
  "expirationDate": "2036-04-16",
  "gazetteNumber": "1996/2",
  "publicationDate": "1996-06-25",
  "holder": "CAMPOMAR, S.L. avenida de España 9 E-11701 CEUTA",
  "representative": "HERRERO & ASOCIADOS",
  "niceClasses": ["03"],
  "goodsAndServices": [{ "niceClass": "03", "text": "Bleaching preparations and other substances for laundry use" }],
  "designations": ["SG", "AT", "BG"],
  "detailUrl": "https://www3.wipo.int/madrid/monitor/api/v1/details/WO50000652471?lang=en"
}
```

```json
{
  "recordType": "patent",
  "source": "WIPO PATENTSCOPE",
  "publicationNumber": "WO/2026/213632",
  "title": "DEVICE AND METHOD FOR TREATING A SOLIDS-CONTAINING LIQUID",
  "kind": "Initial Publication with ISR[A1]",
  "applicationNumber": "AT2026/060095",
  "ipc": "B01F 23/43",
  "applicant": "SIEGA OG",
  "gazetteNumber": "42/2026",
  "gazetteDate": "2026-10-15",
  "detailUrl": "https://patentscope.wipo.int/search/en/detail.jsf?docId=WO2026213632"
}
```

### Automate Trademark Watch With Schedules & Webhooks

- **Brand watch:** schedule a daily or weekly run over your competitor brands, then diff consecutive dataset runs to surface new filings, status changes and expirations.
- **Clearance screening:** run your shortlist of proposed names before filing and archive the results as evidence of the search you performed.
- **Weekly patent gazette:** schedule `latestGazettes: 1` to collect each Thursday's PCT publications as they are released.
- **Warehouse sync:** dataset webhooks push each finished run to Slack, email or a warehouse; recurring runs also improve this actor's Store recommendation signals.

### Related Actors

- [Global Trademarks Scraper — Madrid, EUIPO, USPTO & TMview](https://apify.com/scrapers_lat/tmview-global-trademarks-scraper) — the largest trademark actor in this cluster; covers Madrid registrations alongside 145M+ marks from other offices.
- [Google Patents Scraper](https://apify.com/khadinakbar/google-patents-scraper) — the most-used patent actor; complements the PCT gazette data here.
- [USPTO Trademark Search Scraper](https://apify.com/dev00/uspto-trademark-api) — US federal trademark registrations, the national counterpart to Madrid international registrations.
- [USPTO Patent Search](https://apify.com/nexgendata/uspto-patent-search) — US granted patents and published applications with citations and CPC classes.
- [USPTO Trademark Search — Full Text & Status](https://apify.com/nexgendata/uspto-trademark-search) — USPTO trademark lookup with status and class filters.

### Frequently Asked Questions

#### Why use this actor instead of the official API?

WIPO does not offer a public trademark search API. Its own Madrid Monitor FAQ answers "I want to integrate your database into my project, do you have a public API for direct search access?" with **"Not currently"**, and the terms of use specifically disallow direct automatic querying. The only programmatic routes WIPO sells are paid bulk data products — the complete Madrid backfile and a CHF-priced daily FTP feed (reportedly CHF 30,000/year) — neither of which is practical for on-demand lookups. This actor reads the same public Madrid Monitor surfaces that a browser session uses and returns normalised JSON, which is the practical middle path for small, on-demand samples.

#### What are the alternatives to scraping WIPO trademark data?

Four realistic options:

1. **Paid trademark-watch subscriptions** (Markify/Clarivate, Corsearch, Questel, LegalZoom, law-firm watches) that monitor the registers and email alerts. These start around $39/year for a single-register self-service tier and rise to $2,500–$10,000+ per mark per year at enterprise level. They are strong for alerting but do not hand you the raw structured record.
2. **Third-party normalised trademark APIs** that ingest WIPO's weekly ENOTIF event stream and expose designation-level status. Useful for scale, but a paid dependency.
3. **WIPO's own bulk products** — free weekly Gazette browse and the paid FTP/backfile feeds.
4. **Scraping the public record surfaces**, which is what this actor does.

#### Is there a free WIPO trademark data API?

No. The Madrid Monitor database is a free public *service* but not a free API, and its terms forbid automated queries. This actor wraps the same public surfaces so you get structured output and Apify's export/scheduling/webhook tooling on top; the free Apify plan returns a 10-record preview and paid plans get the full run up to `maxResults`.

#### Can I search by company name instead of brand?

Partially. Madrid Monitor's public lookup is searchable by mark name, IRN and record id; `applicantName` here is a **filter** applied to the records fetched for your query (case-insensitive substring, e.g. `APPLE` also matches `APPLE INC.`). Because the public lookup returns only the top name matches per term, combine a broad brand `query` — or several queries and direct IRNs — with the `applicantName` filter for portfolio work; the actor does not enumerate every mark owned by a company.

#### How do I monitor competitors' trademarks?

Schedule a recurring run for the brands you care about and diff consecutive runs. The dataset is stable and structured (`irn`, `markName`, `status`, `registrationDate`, `expirationDate`, `gazetteNumber`, `publicationDate`), so a new IRN or a changed `status` is easy to detect. For fully event-driven alerting across 190+ registers you would pair this with a paid watch service; for a lightweight free-form watch on Madrid records, this run-and-diff approach works.

#### How often does WIPO update the data?

Madrid Monitor is updated each day once that day's transactions land on WIPO's FTP site, usually in the afternoon Geneva time (CET). The WIPO Gazette of International Marks is published weekly. Realtime register status (documents in examination) is a separate tab and is not part of the daily snapshot this actor reads.

#### Can I get patents and trademarks in one run?

Yes. The dataset mixes both record types and the Output tab has separate Trademarks and Patents views. Trademark fields (mark, holder, Nice classes, goods & services) and patent fields (publication number, title, applicant, IPC) simply populate different subsets of the same schema.

#### Do I need a proxy?

Not for trademark mode. Enable Apify Proxy (residential recommended) only if PATENTSCOPE keyword searches (`patentQueries`) return nothing because of reCAPTCHA on your IP; the PCT gazette mode is unaffected.

### For AI Agents & LLM Apps

**Purpose:** returns WIPO international trademark registrations (Madrid Monitor) and PCT patent publications (PATENTSCOPE gazettes) for given brand terms / IRNs / records / gazette numbers — keyless, no browser, keyed on `irn` and `publicationNumber`.

**Minimal input:**

```json
{ "query": ["NIKE"] }
```

**Direct record lookup:**

```json
{ "query": ["WO50000652471"] }
```

**Patent-gazette variant:**

```json
{ "latestGazettes": 1 }
```

**Output fields:** recordType, source, irn, internationalRegistrationNumber, markName, status, registrationDate, expirationDate, gazetteNumber, publicationDate, holder, representative, niceClasses, goodsAndServices, designations, detailUrl, scrapedAt; patents — publicationNumber, title, applicant, ipc, applicationNumber, kind, gazetteNumber, gazetteDate, docId.

**Behaviors an agent should know:**

- `query` entries are OR-ed and searched independently; an IRN, Madrid record ID or full record URL in `query` triggers a **direct record lookup** instead of a name search.
- `applicantName`, `statuses` and `niceClasses` are **filters applied to already-fetched records**, not search parameters — they never widen the result set. Madrid Monitor's public lookup returns about 10 top matches per term.
- An **empty input** scrapes the latest PCT gazette, not trademarks.
- Each gazette page holds 200 rows; `maxPagesPerGazette` (default 5) and `maxRequestsPerCrawl` (default 25) are the runaway guards.
- `patentQueries` may be blocked by reCAPTCHA on datacenter IPs — enable residential proxy if it returns nothing.

**Billing:** pay-per-event — Trademark record $0.008 each, Patent record $0.0015 each, plus an Actor start event; free accounts get a 10-record preview.

### Legal & Compliance Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the World Intellectual Property Organization (WIPO). It reads only publicly reachable WIPO Madrid Monitor record surfaces and the PATENTSCOPE gazette browser — no login, no WIPO account, and no CAPTCHA solving in trademark mode. WIPO's terms of use restrict bulk acquisition and automated querying of the Madrid Monitor database, and WIPO sells official bulk data products and a paid daily FTP feed for that purpose; this actor fetches small on-demand samples. Users are responsible for their own compliance with WIPO's terms of use and applicable law when storing, redistributing or automating access to the collected data. Trademark and patent records are provided as published at scrape time.

### SEO Keywords

wipo trademark search, madrid monitor, international trademark registration, trademark watch, wipo madrid system, trademark data api, wipo api alternative, madrid monitor api, trademark monitoring tool, brand clearance search, nice class search, goods and services search, pct patent gazette, patentscope search, wipo patents, international registration number lookup, trademark portfolio data, ip due diligence data, trademark database export, brand watch monitoring, patent publication data, wipo madrid scraper, trademark register data, global trademark search

# Actor input Schema

## `query` (type: `array`):

Free-text search on the trademark NAME. Examples: 'apple', 'louis vuitton', 'tesla'. Each entry can also be an international registration number (IRN, e.g. '652471'), a Madrid record ID ('WO50000652471') or a full Madrid Monitor record URL for a direct lookup. Multiple entries are searched independently.

## `applicantName` (type: `array`):

Filter the fetched trademark records by APPLICANT / holder name — case-insensitive substring match, so 'APPLE' also catches 'APPLE INC.'. Multiple names are OR-ed. Madrid Monitor's public lookup returns top name matches only, so combine this filter with a broad brand 'query'.

## `statuses` (type: `array`):

Filter by legal status — case-insensitive substring match. Typical values: 'Active', 'Ended', 'Pending'. Leave empty for all statuses.

## `niceClasses` (type: `array`):

Filter by Nice classification numbers (1-45) — the international trademark goods & services categories. Examples: '9' = electronics/software, '25' = clothing, '35' = advertising, '42' = IT services. A record matches when any of its classes is listed.

## `maxResultsPerQuery` (type: `integer`):

How many Madrid Monitor top matches to read per query entry. The public lookup endpoint returns up to about 10 top matches per term.

## `maxResults` (type: `integer`):

Maximum number of records to store in the dataset across trademarks and patents. Start with 30 to validate filters, then scale up. Each PCT gazette page holds 200 rows.

## `gazettes` (type: `array`):

PCT Gazette issues to scrape, in the form NN/YYYY (for example "42/2026" for gazette 42 of 2026). Each gazette lists every PCT application published that week.

## `latestGazettes` (type: `integer`):

Instead of (or in addition to) explicit gazette numbers, scrape the N most recent PCT gazettes (1 = the gazette published last Thursday).

## `patentQueries` (type: `array`):

Optional keyword queries for the PATENTSCOPE simple search (e.g. "electric car", "WIPO2026"). Note: PATENTSCOPE protects keyword-search result pages with reCAPTCHA on flagged IP addresses — enable Apify Proxy (residential) if searches return no data.

## `patentSearchField` (type: `string`):

PATENTSCOPE field used for the keyword queries.

## `maxPagesPerGazette` (type: `integer`):

How many 200-row pages to fetch per gazette (a large gazette contains several thousand publications).

## `maxRequestsPerCrawl` (type: `integer`):

Safety cap on the total number of HTTP requests the crawler may perform.

## `proxyConfig` (type: `object`):

Select proxies to be used by your crawler. Trademark mode works without a proxy; enable Apify Proxy (residential) for PATENTSCOPE keyword searches if reCAPTCHA blocks them.

## Actor input object example

```json
{
  "query": [
    "NIKE"
  ],
  "applicantName": [],
  "statuses": [],
  "niceClasses": [],
  "maxResultsPerQuery": 10,
  "maxResults": 200,
  "gazettes": [],
  "latestGazettes": 0,
  "patentQueries": [],
  "patentSearchField": "FP",
  "maxPagesPerGazette": 5,
  "maxRequestsPerCrawl": 25,
  "proxyConfig": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "query": [
        "NIKE"
    ],
    "proxyConfig": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/wipo-int-scraper").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 = {
    "query": ["NIKE"],
    "proxyConfig": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/wipo-int-scraper").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 '{
  "query": [
    "NIKE"
  ],
  "proxyConfig": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/wipo-int-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/wipo-int-scraper"
        }
    }
}
```

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/TCdgGaK40ttlzrMho/builds/ijdQu9baW4GawnBSH/openapi.json