# Italy Registro Imprese Company Search Scraper (`automation-lab/italy-registro-imprese-company-search-scraper`) Actor

🏢 Search official public Italian company suggestions in batches for KYB, CRM normalization, supplier discovery, and lead enrichment.

- **URL**: https://apify.com/automation-lab/italy-registro-imprese-company-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## Italy Registro Imprese Company Search Scraper

Search public company-name suggestions from Italy’s official Registro Imprese website and export clean, typed records.

Use this Actor for Italian KYB discovery, CRM name normalization, supplier research, and B2B lead enrichment without relying on paid Telemaco data.

### What does this Italy company scraper do?

The Actor opens the official public Registro Imprese search experience in a real browser session.

It submits company-name or activity queries and captures the public suggestions returned by the site.

Each match includes its query, company name, suggestion category, source URL, and collection timestamp.

Optional fields remain absent unless they are publicly observable. The Actor never invents company details.

### Why use it?

- 🏢 Search multiple Italian company names in one run.
- 🔎 Normalize incomplete or uncertain company names.
- 📊 Export results to JSON, CSV, Excel, XML, or RSS.
- 🔌 Connect results to APIs, webhooks, and automation tools.
- ✅ Distinguish name-only matches from unavailable enrichment.

### Who is it for?

**KYB and onboarding teams** can find candidate legal names before verification.

**Sales operations teams** can normalize Italian account names in a CRM.

**Procurement teams** can discover suppliers by company or activity keyword.

**Data teams** can run repeatable batches instead of performing manual searches.

### What data can I extract?

| Field | Description |
|---|---|
| `query` | Original company or activity query |
| `companyName` | Public suggested company name |
| `suggestionCategory` | Official suggestion grouping |
| `suggestionType` | Typed suggestion classification |
| `province` | Optional province context supplied by the user |
| `sourceUrl` | Public endpoint used for the match |
| `enrichmentStatus` | `not_requested`, `unavailable`, or `enriched` |
| `enrichmentError` | Honest explanation when detail data is unavailable |
| `registeredAddress` | Optional, only when publicly observed |
| `pec` | Optional PEC or digital domicile |
| `legalForm` | Optional generic legal form |
| `activityDescription` | Optional public activity description |
| `ateco` | Optional ATECO code |
| `scrapedAt` | ISO collection timestamp |

### How to search Registro Imprese

1. Add one or more company names or activity keywords.
2. Optionally add an Italian province name or abbreviation.
3. Choose the maximum suggestions per query.
4. Run the Actor.
5. Open the Dataset tab to preview or export matches.

### Input

```json
{
  "queries": ["Ferrari", "Enel", "Barilla"],
  "maxResults": 10,
  "enrichDetails": false,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

`queries` accepts company names, trading names, or activity keywords.

`province` is optional and is added to each search phrase.

`maxResults` controls records per query, from 1 to 100.

`enrichDetails` requests honest best-effort public enrichment.

### Output example

```json
{
  "query": "Enel",
  "companyName": "ENEL ENERGIA S.P.A.",
  "suggestionCategory": "denom",
  "suggestionType": "denom",
  "sourceUrl": "https://risuggester.infocamere.it/raceSuggWeb/suggester?lang=IT&app=RI&q=Enel",
  "enrichmentStatus": "not_requested",
  "scrapedAt": "2026-07-13T00:00:00.000Z"
}
```

### How much does it cost to search Italian companies?

Pricing is pay per event: a small start fee plus one charge for each saved company match.

Volume tiers automatically reduce the per-result rate for larger platform plans.

Check the live pricing panel on Apify before a production batch.

### Batch company-name normalization

Pass a list of names from your CRM as `queries`.

Join each output row back to the original value using `query`.

Review candidate legal names before updating your source system.

### Supplier discovery workflow

Search activity terms such as `costruzioni`, `ristorante`, or `logistica`.

Add a province when geographic context matters.

Export candidate names for a separate verification or contact-enrichment step.

### Enrichment behavior

The proven public surface returns suggestions, not guaranteed complete registry profiles.

When enrichment is unavailable, the row remains useful and explicitly reports that status.

Blank optional fields mean “not publicly observed,” never “known to be empty.”

### Integrations

Send Dataset items to Google Sheets for review.

Trigger Make or Zapier using an Apify webhook after successful runs.

Load JSON into a data warehouse for recurring company-name checks.

Call the Actor from a CRM enrichment service through the Apify API.

### API usage

Use the Apify API from JavaScript, Python, or cURL. Keep your API token secret and pass the same typed input used in Console.

#### JavaScript API example

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/italy-registro-imprese-company-search-scraper').call({
  queries: ['Ferrari', 'Enel'], maxResults: 10
});
console.log(run.defaultDatasetId);
```

### Python API example

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/italy-registro-imprese-company-search-scraper').call(
    run_input={'queries': ['Ferrari', 'Enel'], 'maxResults': 10}
)
print(run['defaultDatasetId'])
```

### cURL API example

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~italy-registro-imprese-company-search-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"queries":["Ferrari","Enel"],"maxResults":10}'
```

### MCP with Claude Code

Install the Actor tool from your terminal:

```bash
claude mcp add apify --transport http 'https://mcp.apify.com?tools=automation-lab/italy-registro-imprese-company-search-scraper'
```

Example prompts:

- “Search Registro Imprese for Ferrari, Enel, and Barilla and return normalized candidates.”
- “Find public construction-company name suggestions with Milan province context.”
- “Compare these CRM account names with official Italian company suggestions.”

#### MCP with Claude Desktop

Add this MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/italy-registro-imprese-company-search-scraper"
    }
  }
}
```

Then ask for Italian company suggestions by name, activity, or province.

### Reliability and anti-blocking

The official endpoint rejects some direct HTTP clients, so this Actor uses Chromium and normal page context.

Queries run sequentially with conservative delays to reduce pressure on the public service.

Enable Apify Proxy only when your network is blocked; direct browser access is the low-cost default.

### Tips for better results

Use distinctive parts of a company name.

Try both abbreviations and expanded legal names.

Use activity terms for discovery and company names for normalization.

Keep `maxResults` low for precise searches.

Split very large query lists into scheduled batches.

### Limitations

Suggestions are candidates, not certified company reports.

The public service may change fields, rate limits, or availability.

Province is search context and does not prove a registered office location.

Detail enrichment is best effort and may remain unavailable.

### Legality and responsible use

This Actor accesses anonymous public search data.

You are responsible for complying with applicable terms, database rights, privacy rules, and your lawful purpose.

Do not use candidate matches as a final compliance decision without authoritative verification.

### Troubleshooting

**No matches returned:** try a shorter or more distinctive query and remove the province.

**Requests are blocked:** enable Apify Proxy and retry a small batch.

**Optional fields are blank:** the detail was not publicly observable; inspect `enrichmentStatus`.

**A run is slow:** reduce query count or schedule smaller batches.

### FAQ

#### Does this require a Registro Imprese account?

No. The Actor uses the anonymous public suggestion surface.

#### Does it access paid Telemaco records?

No. It does not use credentials or paid reports.

#### Are names guaranteed to identify the intended company?

No. Suggestions should be reviewed and verified before decisions.

#### Can I search by activity?

Yes. Add Italian activity phrases to `queries`.

#### Can I filter by province?

You can add province context to the search, but it is not proof of address.

#### Why are address and PEC optional?

They are emitted only when the public surface exposes them.

#### Can I schedule recurring checks?

Yes. Use Apify schedules and compare datasets downstream.

#### Can I export CSV or Excel?

Yes. Use the Dataset export controls or API endpoints.

### Related scrapers

For financial-statement product metadata, use [Italy RegistroImprese Bilanci Scraper](https://apify.com/automation-lab/italy-registroimprese-bilanci-scraper).

Browse other official-source business tools at [Automation Lab](https://apify.com/automation-lab/).

### Support

For reproducible help, include the run URL, input, and the query that behaved unexpectedly.

Do not include private credentials or personal data in support reports.

# Actor input Schema

## `queries` (type: `array`):

Company names, trading names, or activity keywords to search.

## `province` (type: `string`):

Optional Italian province name or abbreviation added to each search.

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

Maximum public company suggestions saved for each query.

## `enrichDetails` (type: `boolean`):

Marks rows for best-effort public enrichment. Unavailable details are reported honestly and never fabricated.

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

Optional Apify Proxy settings for blocked networks.

## Actor input object example

```json
{
  "queries": [
    "Ferrari",
    "Enel",
    "Barilla"
  ],
  "maxResults": 10,
  "enrichDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "queries": [
        "Ferrari",
        "Enel",
        "Barilla"
    ],
    "province": "",
    "maxResults": 10,
    "enrichDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/italy-registro-imprese-company-search-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 = {
    "queries": [
        "Ferrari",
        "Enel",
        "Barilla",
    ],
    "province": "",
    "maxResults": 10,
    "enrichDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/italy-registro-imprese-company-search-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 '{
  "queries": [
    "Ferrari",
    "Enel",
    "Barilla"
  ],
  "province": "",
  "maxResults": 10,
  "enrichDetails": false
}' |
apify call automation-lab/italy-registro-imprese-company-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/italy-registro-imprese-company-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Italy Registro Imprese Company Search Scraper",
        "description": "🏢 Search official public Italian company suggestions in batches for KYB, CRM normalization, supplier discovery, and lead enrichment.",
        "version": "0.1",
        "x-build-id": "lsJCYsCVNhaks3PNi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~italy-registro-imprese-company-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-italy-registro-imprese-company-search-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/automation-lab~italy-registro-imprese-company-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-italy-registro-imprese-company-search-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/automation-lab~italy-registro-imprese-company-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-italy-registro-imprese-company-search-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",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "🏢 Company or activity queries",
                        "type": "array",
                        "description": "Company names, trading names, or activity keywords to search.",
                        "default": [
                            "Ferrari",
                            "Enel",
                            "Barilla"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "province": {
                        "title": "Province",
                        "type": "string",
                        "description": "Optional Italian province name or abbreviation added to each search."
                    },
                    "maxResults": {
                        "title": "Maximum suggestions per query",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum public company suggestions saved for each query.",
                        "default": 10
                    },
                    "enrichDetails": {
                        "title": "Try public detail enrichment",
                        "type": "boolean",
                        "description": "Marks rows for best-effort public enrichment. Unavailable details are reported honestly and never fabricated.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings for blocked networks.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```