# Italy PEC Finder - Lawyers & Engineers Certified Email (`scrapersdelight/inipec-pec-index-scraper`) Actor

Find the PEC (certified email) of Italian lawyers and engineers from the national albi (CNF, CNI) by codice fiscale, name or ordine. Lawyers also get email, phone and P.IVA. $0.005 per PEC found; no charge when none is published.

- **URL**: https://apify.com/scrapersdelight/inipec-pec-index-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Lead generation, Business, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 per pec record founds

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

## Italy PEC Finder: Lawyers & Engineers Certified Email (PEC)

**Get the PEC (posta elettronica certificata) of Italian lawyers and engineers, the certified email Italian law requires every order-registered professional to hold.** The actor reads the two largest national professional registers:

| Register | Members | PEC fill we measured | Also returned |
|---|---|---|---|
| **CNF**: Albo nazionale degli avvocati (lawyers) | 231,299 | **170 of 171** members examined (99.4%) | email, phone, fax, office address, P.IVA, status, district, *cassazionista* flag |
| **CNI**: Albo unico nazionale degli ingegneri (engineers) | 253,691 | **305 of 310** members examined (98.4%) | registration number and date, section A/B, sectors, main activity |

You can use it three ways:

- **Codice fiscale lookup.** Give a list of codici fiscali and get one exact PEC record back for each.
- **Name lookup.** Give `Surname` or `Surname, First name`, optionally narrowed to one ordine.
- **Directory.** Give only an ordine (for example `MILANO` for lawyers, `MI` for engineers) and get its members in register order.

**You are charged only when a PEC is delivered.** A member found without a published PEC, a lookup the register does not know and a lookup we could not reach are all reported in the run summary and never billed.

***

### Why this reads the professional albi and not INI-PEC

INI-PEC (`inipec.gov.it`) is the national index of PEC addresses. Its Professionisti section is built from the lists the professional orders keep. We tested INI-PEC directly on 2026-09-23:

- `/cerca-pec` sits behind an F5 bot-defence challenge (TSPD). A real browser gets past it.
- Every search then requires a Google reCAPTCHA v2 checkbox, and the server checks it. A search sent without the token comes back with `Errore:captcha-not-selected`.

This actor never solves a human-verification CAPTCHA. It reads the orders' own public albi instead, which are the upstream source for INI-PEC's professional records and can be queried without one. The Imprese (company) half of INI-PEC is **not** covered here. See *Honest limits*.

***

### What one row looks like

A real engineer row from a verified run (directory `MI`):

```json
{
  "source": "engineers",
  "register": "CNI - Albo unico nazionale degli ingegneri",
  "profession": "ingegnere",
  "qualification": "INGEGNERE",
  "fullName": "Abatangelo Anna Gabriella",
  "lastName": "Abatangelo",
  "firstName": "Anna Gabriella",
  "pec": "annagabriella.abatangelo@ingpec.eu",
  "pecDomain": "ingpec.eu",
  "pecShapeValid": true,
  "codiceFiscale": "BTNNGB73L68F027M",
  "codiceFiscaleValid": true,
  "ordine": "Milano",
  "registrationNumber": "29390",
  "registrationDate": "28/11/2012",
  "section": "Sezione A",
  "sectors": ["Civile/Ambientale", "Industriale", "Informazione"],
  "mainActivity": "Libero Professionista",
  "registerRecordId": "BTNNGB73L68F027M",
  "query": "ordine:MI",
  "sourceUrl": "https://www.cni.it/albo-unico"
}
```

A real lawyer row from a verified run (directory `ROMA`). Email and phone digits are partly masked in this README only; the dataset returns them as the CNF publishes them:

```json
{
  "source": "lawyers",
  "register": "CNF - Albo nazionale degli avvocati",
  "profession": "avvocato",
  "qualification": "Avvocato Straniero",
  "fullName": "ABATE CESARE",
  "pec": "cesare.abate@pec.it",
  "pecDomain": "pec.it",
  "pecShapeValid": true,
  "email": "cesare•••••@libero.it",
  "phone": "066920••••",
  "fax": "066929••••",
  "address": "VIA DEL CORSO, 117 - 00186, ROMA (RM)",
  "codiceFiscale": "BTACSR74L03B963O",
  "codiceFiscaleValid": true,
  "partitaIva": "04311920617",
  "partitaIvaValid": true,
  "ordine": "ROMA",
  "district": "ROMA",
  "registrationDate": "19/06/2025",
  "status": "Abilitato",
  "statusSince": "19/06/2025",
  "cassazionista": false,
  "registerUpdatedAt": "23/09/2026",
  "registerRecordId": "118/3859320",
  "query": "ordine:ROMA",
  "sourceUrl": "https://www.consiglionazionaleforense.it/ricerca-avvocati"
}
```

***

### Every field, and how often it was filled

Fill counts come from live runs on 2026-09-23. Two ordini are measured per register so that a single city does not stand in for the country.

| Field | Meaning | Lawyers: ROMA (150) · MILANO (20) | Engineers: NAPOLI (300) · MILANO (5) |
|---|---|---|---|
| `pec` | Certified email, exactly as published (lowercased, trimmed). Never constructed or repaired. | **150 · 20** | **300 · 5** |
| `pecDomain` | Provider part of the PEC | 150 · 20 | 300 · 5 |
| `pecShapeValid` | `true` when the PEC is a syntactically valid address. A malformed one is still returned, flagged `false`. | 150 · 20 true | 300 · 5 true |
| `email` | Ordinary email (CNF only) | 146 · 20 | not published by CNI |
| `phone` | Phone (CNF only) | 141 · 15 | not published |
| `fax` | Fax (CNF only) | 98 · 11 | not published |
| `address` | Office address | 150 · 20 | CNI prints "-" for almost everyone (0 of 305) |
| `website` | Website (CNF only) | 9 · 0 | not published |
| `codiceFiscale` | Personal tax code as published | 150 · 20 | 300 · 5 |
| `codiceFiscaleValid` | Check character verified by this actor | 150 · 20 true | 300 · 5 true |
| `partitaIva` | VAT number (CNF only) | 70 · 17 | not published |
| `partitaIvaValid` | Check digit verified. One Rome value was published with 10 digits and is returned as published, flagged `false`. | 69 true · 17 true | n/a |
| `ordine` | Bar association or provincial order | 150 · 20 | 300 · 5 |
| `district` | Court of appeal district (CNF) | 150 · 20 | n/a |
| `registrationNumber` | Albo number (CNI) | n/a | 300 · 5 |
| `registrationDate` | Date registered | 150 · 20 | 300 · 5 |
| `section` | Albo section A / B (CNI) | n/a | 300 · 5 |
| `sectors` | Civil/environmental, industrial, information (CNI) | n/a | 298 · 5 |
| `mainActivity` | Declared main activity (CNI) | n/a | 19 · 1 |
| `status`, `statusSince` | e.g. `Abilitato` (CNF) | 150 · 20 | n/a |
| `cassazionista` | Admitted before the higher courts (CNF) | 150 · 20 | n/a |
| `specializations` | Declared specializations (CNF) | 1 · 0 | n/a |
| `qualification` | e.g. Avvocato, Avvocato Straniero, INGEGNERE | all | all |
| `fullName`, `lastName`, `firstName` | CNF prints one combined name, so `lastName`/`firstName` are CNI only | all | all |
| `registerUpdatedAt` | Date the CNF last refreshed its data | all | n/a |
| `registerRecordId` | The register's own id, used to dedupe before charging | all | all |
| `register`, `profession`, `source`, `query`, `sourceUrl`, `scrapedAt` | Provenance | all | all |

**Not returned:** date and place of birth, sex, and professional-insurance policy numbers. Two fields that appeared in the register's own list, `lingue` and `studi_associati`, were never populated across 170 live lawyer records, so they were removed rather than shipped as empty columns.

***

### Input

| Field | Default | What it does |
|---|---|---|
| `source` | `lawyers` | `lawyers` (CNF) or `engineers` (CNI) |
| `lookups` | empty | One per line. A 16-character codice fiscale gives an exact match. `Surname` or `Surname, First name` gives name matches. |
| `ordine` | empty | Lawyers: bar association as the CNF names it (`MILANO`, `ROMA`, `NAPOLI NORD`, or its numeric code; 140 are accepted). Engineers: provincial sigla (`MI`, `RM`, `NA`). With lookups, it narrows name matches. Without lookups, it lists the ordine. |
| `exactSurnameMatch` | `true` | Both registers match surnames as substrings, so `ROSSI` also returns `GROSSI` and `PETTIROSSI`. This keeps only the exact surname. |
| `maxResults` | `20` | Maximum number of delivered (charged) PEC records per run. |
| `maxMatchesPerLookup` | `10` | How many matches to open for one name lookup |
| `proxyConfiguration` | none | Not needed. Both registers answer Apify's network directly. |

If you leave both `lookups` and `ordine` empty, the actor lists the documented demo scope: `MILANO` for lawyers, `MI` for engineers.

#### Examples

Lawyers by codice fiscale and by name, narrowed to one bar:

```json
{ "source": "lawyers", "lookups": ["GRSCLN56T23F965U", "Esposito"], "ordine": "NAPOLI", "maxMatchesPerLookup": 3 }
```

Every engineer in the Rome order, first 500:

```json
{ "source": "engineers", "ordine": "RM", "maxResults": 500 }
```

***

### Pricing

**$0.005 per PEC record delivered** (`pec-record` event). There is no start fee and no charge for platform usage.

You are **not** charged for:

- members found without a published PEC
- lookups the register does not know
- lookups that stayed unreachable after retries
- duplicates (the same member reached by two of your lookups)

An empty-input run delivers 20 records, which costs $0.10.

### Speed, and why lawyers are slower

- **Engineers:** measured at 300 records in 114 seconds.
- **Lawyers:** about **15 records a minute**. The CNF's API refuses an IP address that makes more than about 100 calls in 5 minutes (HTTP 403 `{"message":"Forbidden"}`, lifted after 2 to 3 minutes). We measured this limit and pace every CNF call at one per 3.5 seconds per IP, which keeps runs inside it. If the IP is refused anyway (Apify's egress addresses are shared), the run moves to one fresh Italian residential session, at most 4 times per run. Runs never fan out across IPs to go faster.
- Measured on lawyers: 150 records in 603 seconds, 0 failed calls. 5 records take about 40 seconds.

A full bar association such as Milan (22,159 lawyers) is therefore a job of many hours. Split it with name lookups, or schedule it.

***

### Run summary (key-value store `RUN_SUMMARY`)

Every run writes the following:

- `delivered` and `charged`
- three uncharged outcome lists:
  - `foundNoPec`: member exists, no PEC published
  - `notFound`: the register does not know the lookup
  - `unreachable`: transport failure after retries
- `invalidInput`
- `filteredNotExactSurname`: substring matches dropped
- `registerTotals`: the register's own count for a listed ordine, which the listing is floor-checked against
- `transport`: requests, bytes, retries, CNF pace, and which IP slot served the run
- `stoppedEarlyBecause`, with the reason whenever a cap, budget or refusal cut the run short
- `runComplete`

### Limits of the data

- **Company PEC (INI-PEC's Imprese section) is not included.** INI-PEC gates it with a CAPTCHA. The official Registro Imprese free search is gated by reCAPTCHA Enterprise. The store actors that sell company PEC and name their source read a private mirror (ufficiocamerale.it), not the register.
- **Only lawyers and engineers.** We also probed commercialisti (CNDCEC: its albo publishes no PEC), architects (CNAPPC: reCAPTCHA on every search), doctors (FNOMCeO: Cloudflare Turnstile), psychologists (CNOP), labour consultants, surveyors, industrial experts and notaries.
- **The CNF may turn on its own CAPTCHA** for an IP. Its site checks `/ricerca/validate` first, and so does this actor. If the check says a CAPTCHA is needed, the lawyers run stops and says so. We never solve it.
- **Lawyers are rate-limited** at about 15 records a minute (see *Speed*).
- **Name lookups read the first 100 register matches.** Narrow very common surnames with a first name or an ordine.
- A PEC is only as current as the register. The CNF stamps each record with `registerUpdatedAt`. The CNI publishes no refresh date.

### FAQ

**Is a PEC the same as an ordinary email?** No. A PEC delivery has the legal value of a registered letter with return receipt. That is why every order-registered professional is required to hold one.

**Why is `address` empty for engineers?** The CNI albo prints "-" in its professional-domicile field for almost everyone. We return `null`, never "-".

**A codice fiscale I passed shows `codiceFiscaleValid: false`.** The actor still looks it up. Omocodia and typos exist. The flag only tells you the check character does not match.

**Can I get lawyers and engineers in one run?** Run the actor twice, once per `source`. Each run reports its own totals.

# Actor input Schema

## `source` (type: `string`):

Which national albo to read. 'lawyers' = CNF Albo nazionale degli avvocati (about 231,000 lawyers; PEC plus email, phone, address and P.IVA). 'engineers' = CNI Albo unico degli ingegneri (about 254,000 engineers; PEC plus registration number, section and sectors).

## `lookups` (type: `array`):

One per line. A 16-character codice fiscale gives an exact match. A name is written 'Surname' or 'Surname, First name' and returns up to 'Max matches per lookup' members. Leave empty to list an ordine instead.

## `ordine` (type: `string`):

Lawyers: the bar association as the CNF names it, e.g. MILANO, ROMA, NAPOLI NORD. Engineers: the two-letter provincial sigla of the Ordine degli Ingegneri, e.g. MI, RM. With lookups it narrows name matches; without lookups it lists that ordine in register order.

## `exactSurnameMatch` (type: `boolean`):

Both registers match the surname as a substring, so ROSSI also returns GROSSI and PETTIROSSI. When on, only members whose surname is exactly the one you typed are kept.

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

Stop after this many delivered PEC records across the whole run. Each delivered record is one charged event.

## `maxMatchesPerLookup` (type: `integer`):

For a name lookup, how many register matches to open (common surnames can match hundreds). A codice fiscale lookup returns at most one member.

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

Optional. Both registers answer Apify's network directly, so no proxy is needed. Set one only if a register starts refusing your runs.

## Actor input object example

```json
{
  "source": "engineers",
  "ordine": "MI",
  "exactSurnameMatch": true,
  "maxResults": 5,
  "maxMatchesPerLookup": 10
}
```

# Actor output Schema

## `records` (type: `string`):

PEC (certified email), name, codice fiscale with checksum flag, ordine, registration data and, for lawyers, email, phone, address and P.IVA.

## `runSummary` (type: `string`):

Delivered vs charged, register totals, and the three kinds of nothing: found without PEC, not found, unreachable.

# 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 = {
    "source": "engineers",
    "ordine": "MI",
    "maxResults": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/inipec-pec-index-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 = {
    "source": "engineers",
    "ordine": "MI",
    "maxResults": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/inipec-pec-index-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 '{
  "source": "engineers",
  "ordine": "MI",
  "maxResults": 5
}' |
apify call scrapersdelight/inipec-pec-index-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapersdelight/inipec-pec-index-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/q6BQQ8nhN1RcEoJ8U/builds/amqNZ4GalvEfkPoIP/openapi.json
