# Portugal Corporate Acts Scraper - Publicações (`regdata/portugal-corporate-acts-scraper`) Actor

Search the official Portuguese Ministry of Justice register of published corporate acts by NIF or entity name. Returns act date, entity, municipality and act type for companies, associations and foundations.

- **URL**: https://apify.com/regdata/portugal-corporate-acts-scraper.md
- **Developed by:** [getregdata](https://apify.com/regdata) (community)
- **Categories:** Agents, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 33.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $18.00 / 1,000 company searches

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Portugal Corporate Acts Scraper - Publicações

Search the **official Portuguese Ministry of Justice register of published corporate acts**
(*Publicações de Atos Societários*) by NIF/NIPC or entity name.

For each company, association or foundation you get its published acts - incorporations, changes to
the articles, appointments of officers, accounts, dissolutions - each with its date, entity,
municipality and act type, as structured JSON.

No API key. No account. The access challenge on the site is handled for you.

### What you get per act

| Field | Example |
|---|---|
| `publicationDate` | `2026-07-20` |
| `nif` | `519365640` |
| `entityName` | `BRITES DAMIÃO - CONSTRUÇÕES, UNIPESSOAL LDA` |
| `municipality` | `Loulé` |
| `actType` | `Constituição de sociedade, designação de membro(s) de órgão(s) social(ais)` |
| `jurisdiction`, `source`, `sourceUrl`, `retrievedAt` | provenance for every row |

### What this is - and is not

This is an **act / event register**, not a company-profile register. It answers *"what has been
published about this entity, and when"* - a timeline of official corporate events. It is ideal for:

- **Monitoring** - detect new incorporations, board changes or dissolutions as they are published.
- **Event-based due diligence** - see a counterparty's published corporate history at a glance.
- **KYB enrichment** - confirm a Portuguese entity is real and active by its recent filings.

It does **not** return a company's current consolidated profile (share capital, current board,
registered address, shareholders). The authoritative full record in Portugal is the paid *Certidão
Permanente*, which this actor does not scrape. If you need the consolidated legal record, this is a
monitoring and verification tool, not a replacement for that certificate.

### Search by NIF or name

- **NIF/NIPC** (9 digits) - the precise criterion; returns that entity's published acts.
- **Entity name** (min 2 characters) - broader; more likely to hit the 200-result ceiling.

Both can be narrowed with **date range** (`dateFrom`/`dateTo`), **district** and **publication
type**. A search that finds nothing returns a clean `no_acts_found` - a trustworthy negative.

### Result ceiling

The register returns **at most 200 acts per search** (20 per page, paged automatically on a single
run). When a query hits that ceiling the run says so in its status message. To reach acts beyond it,
narrow by date range, district or publication type.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `nifs` | array | - | Portuguese NIF/NIPC numbers (9 digits), each looked up separately |
| `entityNames` | array | - | Entity names to search (min 2 chars) |
| `publicationType` | enum | `all` | `all`, `commercial`, `other`, `associations`, `solidarity` |
| `district` | string | - | Restrict to a district, e.g. `Lisboa`, `Porto`, `Faro` |
| `dateFrom` / `dateTo` | string | - | Date range, `YYYY-MM-DD` |
| `maxResultsPerQuery` | integer | 200 | Max acts per query (200 is the register's ceiling) |

Set at least one of `nifs` or `entityNames`. A run with neither fails immediately and is not charged.

#### Example input

```json
{
  "entityNames": ["CONSTRUÇÕES"],
  "district": "Porto",
  "dateFrom": "2026-07-01",
  "maxResultsPerQuery": 100
}
````

### Billing

Charged **per search**, not per act - one query resolves one access challenge and pages through up
to 200 acts on the same session, so the cost is per search regardless of how many acts come back.

A search that finds no acts in scope is still an answer, and is charged: on a screen, "this entity
has no published acts in this period" is a real result. It is written as `lookupStatus:
no_acts_found` so it is never confused with a failure.

Queries that could **not** be retrieved are **not charged**, are never written as result rows, and
are listed in `FAILED_INPUTS` in the run's key-value store.

### Limitations

- **Act register, not a profile** - no consolidated current record, share capital, board or address.
- **200 acts per search, paged** - a register limit; narrow by date/district/type to reach more.
- **Act type and municipality are the register's own text** (Portuguese).
- **Full act body** (the "Conteúdo" of each publication) is not exported in this version - the act
  metadata (who, when, what type, where) is returned.

### Related registry actors

Part of a fleet of official-registry actors across 12+ countries - Poland (KRS, CRBR, KRZ, MSiG,
EKW, KNF, UOKiK, BDO), Germany (Handelsregister), Spain (Registro Mercantil, BORME), Italy, France,
Austria, Belgium, Cyprus (DRCOR), Nigeria (CAC), Colombia (RUES), Slovakia (RPVS beneficial owners),
Czechia, UAE and California.

For Portugal specifically, pair this with a sanctions and PEP screen on the entity names it returns.

***

**Data source:** [Publicações de Atos Societários](https://publicacoes.mj.pt/), Ministério da
Justiça, Portugal. This actor is not affiliated with or endorsed by the Ministério da Justiça.

# Actor input Schema

## `nifs` (type: `array`):

One or more Portuguese tax numbers (NIF/NIPC, 9 digits), each looked up separately. The NIF is the preferred, most precise criterion. Example: '500123456'.

## `entityNames` (type: `array`):

One or more entity names to search, each looked up separately (minimum 2 characters). Name search is broader than a NIF and more likely to hit the register's 200-result ceiling.

## `publicationType` (type: `string`):

Which class of publication to search. 'All' covers everything. 'Commercial' is company (Registo Comercial) and foundation acts. 'Associations' and 'Solidarity' cover the non-profit registers.

## `district` (type: `string`):

Restrict to a Portuguese district by name, e.g. 'Lisboa', 'Porto', 'Faro'. Leave empty for all districts. A district narrows a broad name search below the 200-result ceiling.

## `dateFrom` (type: `string`):

Only acts published on or after this date. Accepts YYYY-MM-DD. Use a date range to narrow a broad search or to monitor recent activity.

## `dateTo` (type: `string`):

Only acts published on or before this date. Accepts YYYY-MM-DD.

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

Maximum acts to export per query. The register returns at most 200 per search (20 per page, paged automatically), so 200 is the ceiling. To reach acts beyond it, narrow by date range, district or publication type.

## `proxyConfiguration` (type: `object`):

Leave this off unless you are running many searches in parallel. A normal run does not need a proxy.

## Actor input object example

```json
{
  "nifs": [
    "500745459"
  ],
  "publicationType": "all",
  "maxResultsPerQuery": 40,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `acts` (type: `string`):

Published corporate-act records in the default dataset.

# 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 = {
    "nifs": [
        "500745459"
    ],
    "maxResultsPerQuery": 40
};

// Run the Actor and wait for it to finish
const run = await client.actor("regdata/portugal-corporate-acts-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 = {
    "nifs": ["500745459"],
    "maxResultsPerQuery": 40,
}

# Run the Actor and wait for it to finish
run = client.actor("regdata/portugal-corporate-acts-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "nifs": [
    "500745459"
  ],
  "maxResultsPerQuery": 40
}' |
apify call regdata/portugal-corporate-acts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=regdata/portugal-corporate-acts-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Portugal Corporate Acts Scraper - Publicações",
        "description": "Search the official Portuguese Ministry of Justice register of published corporate acts by NIF or entity name. Returns act date, entity, municipality and act type for companies, associations and foundations.",
        "version": "1.2",
        "x-build-id": "iBFBLfWOf4Rw9rADZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/regdata~portugal-corporate-acts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-regdata-portugal-corporate-acts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/regdata~portugal-corporate-acts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-regdata-portugal-corporate-acts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/regdata~portugal-corporate-acts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-regdata-portugal-corporate-acts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "nifs": {
                        "title": "NIFs / NIPCs",
                        "type": "array",
                        "description": "One or more Portuguese tax numbers (NIF/NIPC, 9 digits), each looked up separately. The NIF is the preferred, most precise criterion. Example: '500123456'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "entityNames": {
                        "title": "Entity names",
                        "type": "array",
                        "description": "One or more entity names to search, each looked up separately (minimum 2 characters). Name search is broader than a NIF and more likely to hit the register's 200-result ceiling.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "publicationType": {
                        "title": "Publication type",
                        "enum": [
                            "all",
                            "commercial",
                            "other",
                            "associations",
                            "solidarity"
                        ],
                        "type": "string",
                        "description": "Which class of publication to search. 'All' covers everything. 'Commercial' is company (Registo Comercial) and foundation acts. 'Associations' and 'Solidarity' cover the non-profit registers.",
                        "default": "all"
                    },
                    "district": {
                        "title": "District (optional)",
                        "type": "string",
                        "description": "Restrict to a Portuguese district by name, e.g. 'Lisboa', 'Porto', 'Faro'. Leave empty for all districts. A district narrows a broad name search below the 200-result ceiling."
                    },
                    "dateFrom": {
                        "title": "Date from (optional)",
                        "type": "string",
                        "description": "Only acts published on or after this date. Accepts YYYY-MM-DD. Use a date range to narrow a broad search or to monitor recent activity."
                    },
                    "dateTo": {
                        "title": "Date to (optional)",
                        "type": "string",
                        "description": "Only acts published on or before this date. Accepts YYYY-MM-DD."
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum acts to export per query. The register returns at most 200 per search (20 per page, paged automatically), so 200 is the ceiling. To reach acts beyond it, narrow by date range, district or publication type.",
                        "default": 200
                    },
                    "proxyConfiguration": {
                        "title": "Proxy (optional)",
                        "type": "object",
                        "description": "Leave this off unless you are running many searches in parallel. A normal run does not need a proxy.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
