# INPI Marcas: Monitor de Marcas (`cerradodata/inpi-monitor`) Actor

Monitora suas marcas e alerta sobre pedidos semelhantes publicados na RPI do INPI que ainda estão no prazo de oposição.

- **URL**: https://apify.com/cerradodata/inpi-monitor.md
- **Developed by:** [Matheus Cabral](https://apify.com/cerradodata) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 marca monitoradas

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## INPI Marcas: Monitor de Marcas

Toda semana o INPI publica na Revista da Propriedade Industrial (RPI) milhares de novos pedidos de marca. Se algum deles for parecido com a sua marca, você tem um prazo para apresentar **oposição**. Perdido o prazo, a defesa fica bem mais difícil.

Este Actor compara as suas marcas com os pedidos publicados que ainda estão no prazo de oposição e lista os semelhantes, ordenados pelos dias que faltam para o prazo acabar.

### Para quem é

- **Escritórios de marcas** que acompanham a carteira de marcas dos clientes e precisam de um alerta semanal de colidências.
- **Empresas** que querem proteger as próprias marcas sem depender de leitura manual da RPI.

### Como usar

1. Em **Marcas monitoradas**, liste as marcas e as classes de Nice de cada uma (até 500 marcas por execução; pelo menos 1 classe por marca).
2. Escolha o escopo:
   - **Apenas a RPI mais recente** marcado: considera só os pedidos publicados na última RPI. É a opção ideal para rodar toda semana.
   - Desmarcado: considera todos os pedidos que ainda estão no prazo de oposição. Use na primeira execução, para não perder nada que já está correndo.
3. Opcionalmente, defina um **Score mínimo** para receber só as colidências mais fortes.

#### Alerta semanal automático

A RPI sai às terças-feiras. Crie um *Schedule* na Apify para rodar o Actor toda quarta-feira com **Apenas a RPI mais recente** marcado, e configure uma integração (e-mail, Slack, webhook, Google Sheets) para receber o resultado.

#### Exemplo de entrada

```json
{
  "marcas": [
    { "marca": "vigor", "classes": [30] },
    { "marca": "aurora", "classes": [3, 35] }
  ],
  "apenas_rpi_mais_recente": true,
  "score_minimo": 70
}
```

#### Exemplo de saída

Cada colidência encontrada vira uma linha:

```json
{
  "marca_monitorada": "vigor",
  "classes_monitoradas": [30],
  "processo": "...",
  "nome": "VIGORE",
  "classes_nice": [30],
  "titulares": ["..."],
  "score": 92,
  "motivo": "fonetico",
  "data_pub": "2026-11-03",
  "rpi_pub": 2913,
  "cod_pub": "IPAS009",
  "prazo_estimado": "2027-01-02",
  "dias_restantes": 59,
  "ultimo_despacho": "IPAS009",
  "ultima_rpi": 2913,
  "data_deposito": "2026-08-10",
  "rpi_base": 2913,
  "erro": null
}
```

| Campo | Significado |
|---|---|
| `marca_monitorada`, `classes_monitoradas` | A sua marca, como informada na entrada. |
| `processo`, `nome`, `classes_nice`, `titulares` | O pedido semelhante publicado na RPI. |
| `score`, `motivo` | Grau e tipo de semelhança (veja abaixo). |
| `data_pub`, `rpi_pub`, `cod_pub` | Data, número da RPI e código do despacho da publicação que abriu o prazo. |
| `prazo_estimado`, `dias_restantes` | Fim estimado do prazo de oposição e dias que faltam. |
| `rpi_base` | Última RPI incluída na base no momento da consulta. |

A visão **Colidências por prazo** do dataset mostra o essencial: dias restantes, prazo estimado, marca monitorada, marca colidente, score e processo. Dentro de cada marca monitorada, as colidências vêm do prazo mais curto para o mais longo.

O registro `OUTPUT` do key-value store traz um resumo da execução: total de marcas, marcas processadas, total de colidências e o aviso sobre o cálculo do prazo.

**Marca sem colidência também aparece no resultado.** Ela gera uma linha com `marca_monitorada` e `rpi_base` preenchidos e os campos da colidência vazios. Isso confirma que a marca foi verificada. Essa linha não é um alerta: só é cobrado o evento "Marca monitorada". Marcas inválidas (sem classe, nome com menos de 2 ou mais de 120 caracteres) geram uma linha com a coluna `erro` preenchida e não são cobradas.

### Como ler o `score` e o `motivo`

- **`score`** vai de 0 a 100 e indica o quanto o pedido publicado se parece com a sua marca. 100 significa nome idêntico.
- **`motivo`**:
  - `texto`: a grafia é igual ou muito parecida;
  - `fonetico`: os nomes soam parecido, mesmo escritos de forma diferente;
  - `contem`: a sua marca aparece dentro do nome publicado.

Uma colidência listada aqui é um sinal para análise, não uma conclusão de que cabe oposição.

### Quanto custa

O Actor é cobrado por evento:

- **Marca monitorada**: uma vez por marca de entrada processada com sucesso.
- **Alerta de colidência**: uma vez por colidência gravada no dataset (depois do filtro de score mínimo).

Marcas inválidas e falhas da API não são cobradas. O preço atual aparece na aba *Pricing* da página do Actor. Se você definir um limite de gasto, o Actor para quando o limite é atingido, informa no log quantas marcas ficaram pendentes e termina com sucesso.

### Aviso importante

Esta ferramenta é um **apoio à pesquisa** e **não constitui parecer jurídico**.

O **prazo de oposição exibido é estimado**: são 60 dias contados a partir da data de publicação na RPI, e o valor é **apenas informativo**. A **contagem oficial do prazo é responsabilidade do usuário**, que deve conferi-la nas regras do INPI (incluindo dias não úteis e eventuais suspensões de prazo) antes de tomar qualquer providência.

### Fonte dos dados

Dados públicos da **Revista da Propriedade Industrial (RPI)**, publicada semanalmente pelo Instituto Nacional da Propriedade Industrial (INPI). Este Actor não tem vínculo com o INPI.

# Actor input Schema

## `marcas` (type: `array`):

Lista de 1 a 500 marcas no formato {"marca": "...", "classes": \[...]}. "marca" deve ter de 2 a 120 caracteres e "classes" precisa de pelo menos uma classe de Nice (1 a 45).

## `apenas_rpi_mais_recente` (type: `boolean`):

Marque para considerar só as publicações da RPI mais recente (ideal para um alerta semanal agendado). Desmarcado, considera todos os pedidos com prazo de oposição aberto.

## `score_minimo` (type: `integer`):

Grava só as colidências com score igual ou maior que este valor (0 a 100). Use 0 para receber todas.

## Actor input object example

```json
{
  "marcas": [
    {
      "marca": "vigor",
      "classes": [
        30
      ]
    },
    {
      "marca": "aurora",
      "classes": [
        3,
        35
      ]
    }
  ],
  "apenas_rpi_mais_recente": false,
  "score_minimo": 0
}
```

# Actor output Schema

## `colidencias` (type: `string`):

Uma linha por colidência encontrada, com o prazo de oposição estimado (informativo).

## `resumo` (type: `string`):

Total de marcas, total de colidências e aviso sobre o cálculo do prazo.

# 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 = {
    "marcas": [
        {
            "marca": "vigor",
            "classes": [
                30
            ]
        },
        {
            "marca": "aurora",
            "classes": [
                3,
                35
            ]
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("cerradodata/inpi-monitor").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 = { "marcas": [
        {
            "marca": "vigor",
            "classes": [30],
        },
        {
            "marca": "aurora",
            "classes": [
                3,
                35,
            ],
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("cerradodata/inpi-monitor").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 '{
  "marcas": [
    {
      "marca": "vigor",
      "classes": [
        30
      ]
    },
    {
      "marca": "aurora",
      "classes": [
        3,
        35
      ]
    }
  ]
}' |
apify call cerradodata/inpi-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cerradodata/inpi-monitor"
        }
    }
}
```

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/FmKjcebEO57j2HAQ6/builds/zRipJjbaWPesZ4jYx/openapi.json