# Italy RegistroImprese Financial Statements Scraper (`automation-lab/italy-registroimprese-bilanci-scraper`) Actor

Find Italian company names in RegistroImprese public suggestions and collect official balance-sheet product links for KYB workflows.

- **URL**: https://apify.com/automation-lab/italy-registroimprese-bilanci-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 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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 RegistroImprese Financial Statements Scraper

Extract public RegistroImprese company-name suggestions and balance-sheet document catalog links for Italian KYB, credit-risk, accounting, and corporate-finance workflows.

### What does Italy RegistroImprese Financial Statements Scraper do?

This actor queries the same public InfoCamere suggester endpoint used by the RegistroImprese search widget.

It returns official public company-name suggestions for Italian company keywords.

It also includes the official RegistroImprese balance-sheet product page for each discovered company suggestion.

The actor is designed for discovery and monitoring workflows before a user purchases official documents.

It does not bypass login, payment, reCAPTCHA, or account-only document download flows.

### Who is it for?

KYB teams can resolve Italian company names before diligence.

Credit-risk teams can build monitoring lists for annual accounts.

Corporate-finance teams can normalize target-company names.

Accounting teams can prepare balance-sheet purchase queues.

B2B data vendors can enrich Italian-company discovery pipelines.

Legal and compliance analysts can verify which names appear in RegistroImprese public search suggestions.

### Why use this actor?

RegistroImprese is the official Italian company registry portal.

Manual portal searches are slow when you have many names to check.

This actor converts keyword lists into structured dataset rows.

It records the source URL and public bilancio product URL for auditability.

It is safe for discovery because paid document retrieval is out of scope.

### What data can you extract?

| Field | Description |
| --- | --- |
| query | Original input keyword |
| resultType | Company suggestion or optional search hint |
| companyName | Public RegistroImprese company-name suggestion |
| activityOrDescription | Optional activity/declaratory search hint |
| activityCode | Activity-code payload when present |
| rank | Rank within the suggestion group |
| matchWeight | Source-provided weight when present |
| financialStatementProductUrl | Official bilancio product page |
| registrySearchUrl | Public RegistroImprese search URL |
| suggesterApiUrl | Source API URL used for the row |
| scrapedAt | Extraction timestamp |

### How much does it cost to scrape RegistroImprese bilanci discovery data?

The actor uses pay-per-event pricing.

You pay a small run-start fee plus a per-result fee.

The final Store price is calculated from cloud run cost measurements before publication.

Use low limits for exploratory runs.

Use portfolio-sized query lists only after confirming the output matches your workflow.

### How to use the actor

Open the actor on Apify.

Add one or more Italian company names or keywords to `queries`.

Keep `maxItemsPerQuery` at 10 to get the full public suggestion group.

Optionally enable activity-code or declaratory hints.

Start the run.

Download the dataset as JSON, CSV, Excel, or through the API.

### Input example

```json
{
  "queries": ["FIAT", "ENEL", "FERRARI"],
  "maxItemsPerQuery": 10,
  "includeActivityHints": false,
  "includeDeclaratoryHints": false
}
````

### Output example

```json
{
  "query": "FIAT",
  "resultType": "company_name_suggestion",
  "companyName": "FIAT CHRYSLER FINANCE S.P.A.",
  "rank": 3,
  "sourcePortal": "RegistroImprese / InfoCamere public suggester",
  "documentCatalog": ["Bilancio d'esercizio", "Visura camerale ordinaria/storica", "Fascicolo impresa"],
  "financialStatementProductUrl": "https://www.registroimprese.it/bilancio-d-esercizio",
  "registrySearchUrl": "https://www.registroimprese.it/ricerca-libera-e-acquisto?q=FIAT%20CHRYSLER%20FINANCE%20S.P.A.",
  "scrapedAt": "2026-07-07T00:00:00.000Z"
}
```

### Tips for better results

Use official or common company names.

Try brand names when legal names are unknown.

Use Italian spelling for local businesses.

Run multiple related names to build monitoring queues.

Enable activity hints when you need broader sector discovery.

Keep paid document retrieval outside automated workflows unless you have the proper account rights.

### Integrations

Send output to a KYB review spreadsheet.

Join company suggestions with your CRM account list.

Feed normalized names into credit-risk monitoring tools.

Use the bilancio product URL as a manual document-purchase handoff.

Store results in a data warehouse for recurring portfolio checks.

Trigger follow-up Apify actors for broader company-registry enrichment.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/italy-registroimprese-bilanci-scraper').call({
  queries: ['FIAT', 'ENEL'],
  maxItemsPerQuery: 10
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/italy-registroimprese-bilanci-scraper').call(run_input={
    'queries': ['FIAT', 'ENEL'],
    'maxItemsPerQuery': 10,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~italy-registroimprese-bilanci-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"queries":["FIAT","ENEL"],"maxItemsPerQuery":10}'
```

### MCP usage

Use the Apify MCP server with Claude Desktop or Claude Code.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/italy-registroimprese-bilanci-scraper
```

Claude Code setup:

```bash
claude mcp add apify-registroimprese https://mcp.apify.com/?tools=automation-lab/italy-registroimprese-bilanci-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-registroimprese": {
      "url": "https://mcp.apify.com/?tools=automation-lab/italy-registroimprese-bilanci-scraper"
    }
  }
}
```

Example prompts:

- Run the RegistroImprese bilanci scraper for FIAT, ENEL, and Ferrari.
- Export Italian company suggestions as CSV.
- Compare returned company names with my KYB watchlist.

### Legality

This actor accesses public suggestion data.

It does not download paid official documents.

It does not attempt to bypass reCAPTCHA.

It does not log in to private RegistroImprese accounts.

Always follow RegistroImprese terms and local laws.

Use official paid channels for legally certified documents.

### Troubleshooting

If a query returns no results, try a shorter company name.

If the output includes activity hints instead of companies, disable optional hint fields.

If you need actual balance-sheet PDFs, use the official RegistroImprese purchase workflow.

If you need more than 10 suggestions per query, split the search into more specific terms.

### FAQ

#### Does this actor download Italian financial statements?

No. It provides discovery metadata and links to official product pages.

#### Is RegistroImprese the official source?

Yes. RegistroImprese is the official Italian company registry portal operated through InfoCamere and Chambers of Commerce.

#### Can I use it for recurring monitoring?

Yes. Schedule the actor with the same `queries` list and compare datasets over time.

#### Why do some rows contain activity codes?

Those rows appear only when optional hint extraction is enabled.

### Related scrapers

Explore other automation-lab actors for company, website, and B2B data workflows.

Useful companion categories include company enrichment, contact discovery, and web monitoring.

### Data quality notes

The actor returns public suggestions exactly as provided by the source endpoint.

Names may include punctuation, legal-form suffixes, or historical entities.

Treat suggestions as discovery leads, not certified registry extracts.

Use official paid documents when legal certainty is required.

### Operational boundaries

The actor is HTTP-only and lightweight.

It uses browser-like headers to access the public suggester.

It does not need residential proxies for normal operation.

It is designed for low-cost batch discovery.

### Changelog

Initial version extracts public RegistroImprese company suggestions and bilancio product links.

### Support

If a public query fails, include the input JSON and run ID when asking for help.

If the target changes its public suggester, the actor can be updated without changing your downstream schema.

# Actor input Schema

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

Italian company names, brands, VAT fragments, or business keywords to resolve through RegistroImprese public search suggestions.

## `maxItemsPerQuery` (type: `integer`):

RegistroImprese returns up to 10 suggestions per group. Keep this low for quick first runs.

## `includeActivityHints` (type: `boolean`):

Also emit RegistroImprese activity-code suggestions that can be used to refine company searches.

## `includeDeclaratoryHints` (type: `boolean`):

Also emit declaratory/business-description suggestions when available.

## Actor input object example

```json
{
  "queries": [
    "FIAT",
    "ENEL",
    "FERRARI"
  ],
  "maxItemsPerQuery": 10,
  "includeActivityHints": false,
  "includeDeclaratoryHints": 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": [
        "FIAT",
        "ENEL",
        "FERRARI"
    ],
    "maxItemsPerQuery": 10,
    "includeActivityHints": false,
    "includeDeclaratoryHints": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/italy-registroimprese-bilanci-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": [
        "FIAT",
        "ENEL",
        "FERRARI",
    ],
    "maxItemsPerQuery": 10,
    "includeActivityHints": False,
    "includeDeclaratoryHints": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/italy-registroimprese-bilanci-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": [
    "FIAT",
    "ENEL",
    "FERRARI"
  ],
  "maxItemsPerQuery": 10,
  "includeActivityHints": false,
  "includeDeclaratoryHints": false
}' |
apify call automation-lab/italy-registroimprese-bilanci-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Italy RegistroImprese Financial Statements Scraper",
        "description": "Find Italian company names in RegistroImprese public suggestions and collect official balance-sheet product links for KYB workflows.",
        "version": "0.1",
        "x-build-id": "X3u3AUR8sWwo8Ry2G"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~italy-registroimprese-bilanci-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-italy-registroimprese-bilanci-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-registroimprese-bilanci-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-italy-registroimprese-bilanci-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-registroimprese-bilanci-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-italy-registroimprese-bilanci-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 names or keywords",
                        "minItems": 1,
                        "type": "array",
                        "description": "Italian company names, brands, VAT fragments, or business keywords to resolve through RegistroImprese public search suggestions.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "FIAT",
                            "ENEL",
                            "FERRARI"
                        ]
                    },
                    "maxItemsPerQuery": {
                        "title": "Maximum suggestions per query",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "RegistroImprese returns up to 10 suggestions per group. Keep this low for quick first runs.",
                        "default": 10
                    },
                    "includeActivityHints": {
                        "title": "Include activity-code hints",
                        "type": "boolean",
                        "description": "Also emit RegistroImprese activity-code suggestions that can be used to refine company searches.",
                        "default": false
                    },
                    "includeDeclaratoryHints": {
                        "title": "Include business-description hints",
                        "type": "boolean",
                        "description": "Also emit declaratory/business-description suggestions when available.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
