# INPI Trademark Search: French, EU & International Marks (`alexmorain/inpi-trademark-scraper`) Actor

Search French, EU and international trademarks through the official INPI API: every mark of a search past the 200-per-page limit that drops 30 to 45% of results, search by SIREN of the applicant, Nice classes, filing dates, SIREN and goods from the notice. Uses your free INPI account.

- **URL**: https://apify.com/alexmorain/inpi-trademark-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** Business, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 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

### What does INPI Trademark Scraper do?

**INPI Trademark Scraper** searches the official trademark base of [INPI](https://data.inpi.fr), the French IP office, through its **official API**, and returns **every mark of a search**: French marks (INPI, since 1976), European Union marks (EUIPO) and international marks (WIPO, Madrid system). Search by **trademark name**, by **SIREN of the applicant** (the trademark portfolio of a French company), by applicant or holder name, by Nice class, or list every mark filed in a period. Turn on **details** to read the full INPI notice of French marks: SIREN and address of the applicant, goods and services text, representative, history.

It is an **INPI API alternative that does the hard part for you**: login, pacing under the INPI rate limit, and full results past the 200-per-page limit of the API. It runs on your own free INPI API account (setup in 5 minutes, see below).

#### The INPI API silently drops 30 to 45% of the marks

The INPI search API serves 200 marks per page, and paging through the results does not work: pages overlap, their order changes from one call to the next, and past position 500 the API stops answering. A tool that pages through the results returns duplicates and misses marks without telling you. This Actor never pages. It splits a large search by application number until each part fits in one page, then returns each mark once.

| French marks, measured on 28 October 2026 | INPI announces | Paging through the API | This Actor |
|---|---|---|---|
| Filed on 1 October 2026 | 456 | 293 to 349 distinct, depending on the sort order | **456** |
| Filed in October 2026 | 1,243 | 688 distinct | **1,243** |

Every run writes the proof in its `SUMMARY` record: for each search and office, the count announced by INPI and the count returned.

### Why use INPI Trademark Scraper?

- **Trademark clearance**: before naming a product or a company, list every mark in force with the same words, in your Nice classes, in France, the EU and internationally.
- **Competitor portfolios**: give the SIREN of a French company and get all the marks it filed. The SIREN is not in TMview or in the EUIPO search, and the INPI search never returns it: this Actor copies the SIREN you searched onto each row, and the details option reads it from the notice of each French mark, ready to join with SIRENE or your CRM.
- **Watching new filings**: schedule a weekly run in **New marks only** mode on a name, a competitor or a filing date range, and get only the marks filed since the last run, with a Slack or Discord message.
- **Lead generation and market studies**: list every French mark filed in a class over a month, with applicant names.

What you get on top of the raw API:

- Full results past the 200 per page, duplicates removed before they are charged
- Search by SIREN, applicant or holder name, words with wildcards, Nice classes, filing dates, marks in force only
- The three offices in one run: FR, EU, WO
- Login, session renewal and pacing at 10 requests per minute, the limit set by the INPI terms of use
- When your hourly INPI quota runs out, the Actor waits for it to refill if the run has time, then carries on

As an Apify Actor, it runs on a schedule, from the API, or from Make, Zapier, n8n and other integrations, with run monitoring included.

### What data can INPI Trademark Scraper extract?

| Field | Type | Description |
|---|---|---|
| `mark` | string | Trademark name (word element) |
| `applicationNumber` | string | Number at the office |
| `office` | string | FR (INPI), EU (EUIPO) or WO (WIPO) |
| `niceClasses` | array | Nice classes of goods and services |
| `status` | string | Current status, for example "Marque enregistrée", "Demande publiée", "Registered" |
| `applicants` | array | Applicant names as filed (French and international marks) |
| `applicationDate`, `registrationDate`, `expiryDate` | string | Filing, registration and expiry dates, YYYY-MM-DD |
| `noticeUrl` | string | Page of the mark on data.inpi.fr (French and EU marks) |
| `searchInput`, `searchType` | string | The search that found the mark |
| `searchedSiren` | string | The SIREN searched, on rows found by SIREN |
| `source`, `sourceUpdatedAt` | string | INPI as the source, and the date of the latest update of the base |

With **details** on, each French mark also gets:

| Field | Type | Description |
|---|---|---|
| `applicantSirens` | array | SIREN of the applicants and holders |
| `applicantDetails`, `holderDetails` | array | Name, SIREN, street, postcode, city, country |
| `goodsAndServices` | array | Full text of the goods and services, by Nice class |
| `markType` | string | Word, Figurative, Combined... |
| `representatives` | array | Trademark attorney or agent, with address |
| `events` | array | Publications, registration, renewals, with BOPI issue and date |

### How to search French trademarks with INPI Trademark Scraper

1. Get your free INPI API account (next section). It takes 5 minutes and one email.
2. Open the Actor, fill in **INPI username** (your email) and **INPI password** (the API password you created).
3. Type one or more trademark names, SIREN numbers or applicant names. Add Nice classes or filing dates if you want.
4. Click **Start**. Each INPI request returns up to 200 marks, about 10 requests per minute.
5. Download the results as JSON, CSV or Excel, or get them through the Apify API.

#### How to get an INPI API account

The INPI API is free. Each user needs an account of their own: the INPI terms of use make credentials personal.

1. Create an account on [data.inpi.fr](https://data.inpi.fr/login) with a valid email, or log in to your existing account.
2. In **Mon espace client**, open the tab **Accès APIs PI** ([direct link](https://data.inpi.fr/espace_personnel/acces)) and select **Marques**.
3. You receive an activation email from nepasrepondre@inpi.fr. Its link lets you set the password of your **API account** on api-gateway.inpi.fr. This password is the one to give to the Actor; it can differ from your data.inpi.fr password.

Without credentials, the Actor runs a demo: one search, one office, 10 marks, with no charge for the marks (only the $0.002 start fee).

### How much does it cost to search INPI trademarks?

The Actor uses pay-per-event pricing: you pay for the marks you get, nothing for the waiting time.

- **$1.00 per 1,000 marks** on the Free plan, less on paid Apify plans (down to $0.50 per 1,000).
- **$3.00 per 1,000 French marks with details** (down to $1.50), charged instead of the basic price, not on top of it.
- A tiny start fee per run ($0.002).
- A mark found by two of your searches in the same run is charged once. In **New marks only** mode, marks returned by earlier runs are not charged again.

Set **Maximum marks** or a maximum charge per run to cap the cost. The INPI API itself is free.

#### How fast is it?

INPI allows 10 requests per minute and 100 requests per hour per account. One request returns up to 200 marks: the 1,243 French marks filed in October 2026 took 22 requests and a few minutes. A very large search, tens of thousands of marks, uses the hourly quota: the Actor then waits for the next hour if the run timeout allows it (default timeout one hour), or stops and tells you when to run again.

Details cost one request per French mark, so about 90 detailed marks per hour. Use them on a SIREN portfolio or a short list, not on a whole month of filings.

### Input

See the **Input** tab for every option. A few details:

- **Trademark names**: all the words of a line must match. `*` replaces any characters: `kiw*` finds kiwi and kiwiz.
- **Applicant SIREN numbers**: French marks only. INPI holds the SIREN of the applicant, or of the last holder who renewed the mark.
- **Only marks in force**: on by default. The EU and international parts of the INPI base only hold marks in force; for French marks, turn it off to include expired marks since 1976.
- **Filing date range alone** lists every mark filed in the period, for example every French mark filed last week.
- **Advanced query** accepts the INPI search syntax, for experts.

Input example:

```json
{
    "inpiUsername": "you@example.com",
    "inpiPassword": "********",
    "searchTerms": ["kiwi"],
    "niceClasses": ["29", "31", "32"],
    "offices": ["FR", "EU"],
    "onlyInForce": true,
    "maxItems": 500
}
```

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
[
    {
        "mark": "EXAMPLE KIWI",
        "applicationNumber": "5000001",
        "office": "FR",
        "niceClasses": [29, 31],
        "status": "Marque enregistrée",
        "applicants": ["EXAMPLE COMPANY SAS"],
        "applicationDate": "2025-01-15",
        "registrationDate": "2025-05-02",
        "expiryDate": "2035-01-15",
        "noticeUrl": "https://data.inpi.fr/marques/FR5000001",
        "ukey": "FMARK|5000001",
        "searchInput": "kiwi",
        "searchType": "term",
        "searchedSiren": null,
        "source": "INPI (data.inpi.fr)",
        "sourceUpdatedAt": "2026-10-23"
    }
]
```

The `SUMMARY` record of the run's key-value store gives, for each search and office: status, count announced by INPI, marks returned, requests used, duplicates and already seen marks skipped.

### Tips

- **Watch a name or a competitor**: set **Run mode** to New marks only and schedule the Actor weekly. INPI updates its base every Friday.
- **Clearance in your field**: combine the name with your Nice classes; a search without classes returns every sector.
- **Big lists**: a whole month of French filings is about 1,200 to 1,500 marks and takes a few minutes.
- **Your INPI quota is yours**: other tools using the same INPI account share the 100 requests per hour.

### FAQ

#### Is it legal to reuse INPI trademark data?

Yes. INPI publishes its trademark data under its reuse licence for industrial property data, which allows commercial reuse, provided you cite the source and the date of the latest update. Each row carries both (`source`, `sourceUpdatedAt`). Logos and figurative elements remain the property of the trademark holders and are not returned. Applicant names can be names of natural persons: personal data is protected by the GDPR, process it only with a legitimate reason.

This Actor is not affiliated with, endorsed by or sponsored by INPI. It calls the official API with your own account and within its limits.

#### Why does the Actor need my INPI account?

The INPI terms of use make API credentials personal and limit each account to 10 requests per minute. Using your own free account keeps you within those terms and gives you your own quota. Your password is stored encrypted by Apify and never written to the logs.

#### Why is a mark missing?

Check the `SUMMARY` record: the count announced by INPI and the count returned should match. If they don't, the summary says why (quota used up, run timeout, maximum marks reached). INPI updates its base weekly, so a mark filed a few days ago may not be there yet.

#### What does the INPI base not have?

- No applicant name for EU marks: INPI does not return it. Search them by name, and check the applicant on the EUIPO site.
- No status for most international marks, and no data.inpi.fr page for them (`noticeUrl` is empty).
- Details exist for French marks only: the INPI API has no notice for EU and international marks.
- EU and international marks are in the base only while in force. French marks go back to 1976, expired ones included.

#### Can I search by SIREN for EU or international marks?

No. INPI only holds the SIREN of applicants of French marks. For EU and international marks, search by applicant name.

Questions, bugs, a field you need? Open an issue in the **Issues** tab, it gets answered quickly. For programmatic access, see the **API** tab.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [INPI Trademark Scraper page](https://alexis.morain.fr/en/scrapers/inpi-trademark-scraper/) of my site. The [Lead generation family page](https://alexis.morain.fr/en/scrapers/families/lead-generation/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

## `inpiUsername` (type: `string`):

Email of your INPI account with API access activated. Requests run on your own account and its INPI quota (100 requests per hour). Leave empty for a 10-mark demo, marks not charged.

## `inpiPassword` (type: `string`):

Password of the same INPI account. Stored encrypted by Apify, never logged.

## `searchTerms` (type: `array`):

One search per line. Marks containing <b>all</b> the words of the line are returned. Use <code>*</code> as a wildcard: <code>sol*</code> finds soleil, solar, solution.

## `applicantSirens` (type: `array`):

9-digit SIREN of a French company: returns the French marks it filed, its trademark portfolio. Not available for EU and international marks (INPI does not hold their SIREN). The SIREN is copied into each row, as INPI never returns it.

## `applicantNames` (type: `array`):

Company or person name, matched on the applicant and on the current holder. All words of the line must match.

## `rawQuery` (type: `string`):

For experts: a query in the INPI search syntax, for example <code>\[Mark=apple] OU \[Mark=pomme]</code>. The filters below still apply.

## `offices` (type: `array`):

<b>FR</b>: French marks (INPI). <b>EU</b>: European Union marks (EUIPO). <b>WO</b>: international marks designating France (WIPO, Madrid). All three by default.

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

Only marks registered in at least one of these classes. Empty: all classes.

## `onlyInForce` (type: `boolean`):

On: only marks that have not expired today. Off: expired marks too.

## `filingDateFrom` (type: `string`):

Only marks filed on or after this date. With a filing date range alone, the Actor lists every mark filed in the period: a watch of new filings.

## `filingDateTo` (type: `string`):

Only marks filed on or before this date.

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

The run stops after this many unique marks. Each INPI request returns up to 200 marks, and your INPI account allows 100 requests per hour.

## `includeDetails` (type: `boolean`):

Reads the full INPI notice of each French mark: <b>SIREN and address of the applicant</b>, full text of the goods and services by class, type of mark, representative, history (publications, registration, renewals).<br><br>One extra INPI request per mark, so about 90 marks per hour with your INPI quota. EU and international marks have no notice in the INPI API and are returned without details, at the basic price.

## `mode` (type: `string`):

<b>New marks only</b> remembers the marks already returned for this input and returns (and charges) only the new ones. Schedule it daily or weekly to watch a name, a competitor or a class for new filings.

## `registryKey` (type: `string`):

Optional. By default the memory of seen marks is tied to the exact search and filters. Give a name to keep it when you edit the input.

## `webhookUrl` (type: `string`):

If set, the Actor POSTs a short JSON summary to this URL at the end of the run, <b>only when at least one mark was returned</b>. It carries <code>text</code> and <code>content</code> fields, so a Slack or Discord incoming webhook works as is. An unreachable webhook is logged and never fails the run.

## Actor input object example

```json
{
  "searchTerms": [
    "soleil"
  ],
  "offices": [
    "FR",
    "EU",
    "WO"
  ],
  "onlyInForce": true,
  "maxItems": 100,
  "includeDetails": false,
  "mode": "all"
}
```

# Actor output Schema

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

All marks in the default dataset.

## `summary` (type: `string`):

For each search and office: status, marks announced by INPI, marks returned, requests used, duplicates and already seen marks skipped, and the update date of each office.

# 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 = {
    "searchTerms": [
        "soleil"
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/inpi-trademark-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 = {
    "searchTerms": ["soleil"],
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/inpi-trademark-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 '{
  "searchTerms": [
    "soleil"
  ],
  "maxItems": 100
}' |
apify call alexmorain/inpi-trademark-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alexmorain/inpi-trademark-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/gHcuhwWjQ8wB5pA49/builds/I5R1vYpaVu7RUDimB/openapi.json
