# Ireland Company Registry Scraper - CRO (`regdata/ireland-cro-company-scraper`) Actor

Search the official Irish company register (CRO) by name or number. Returns registered name, CRO number, type, status, incorporation date, registered address and email. No API key.

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

## Pricing

from $24.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

## Ireland Company Registry Scraper - CRO

Look up Irish companies in the official **CRO** (Companies Registration Office) register via its
CORE system.

Search by company name or CRO number and get the registered name, CRO number, company type, status,
**incorporation date, full registered address, registered email and annual-return-due date** as
structured JSON — the identity, standing and contact record for verifying an Irish counterparty.

No API key.

### What you get per company

| Field | Example |
|---|---|
| `companyName` | `RYANAIR DESIGNATED ACTIVITY COMPANY` |
| `companyNumber` | `104547` |
| `companyType` | `DAC - Designated Activity Company` |
| `status` / `statusEffectiveDate` | `Normal` / `1984-11-28` |
| `incorporationDate` | `1984-11-28` |
| `registeredAddress` | `RYANAIR DUBLIN OFFICE, AIRSIDE BUSINESS PARK, SWORDS CO. DUBLIN, Ireland` |
| `addressCity` / `addressPostcode` / `addressCountry` | `SWORDS` / `D02 DT85` / `Ireland` |
| `registeredEmail` | `info@ryanair.com` (when present) |
| `annualReturnDueDate` | `2026-10-09` |
| `jurisdiction`, `source`, `sourceUrl`, `retrievedAt` | provenance for every row |

### What this is good for

- **KYB / onboarding** - confirm an Irish company exists, its type, and that it is in `Normal`
  standing (not `Dissolved`, `Liquidation` or `Receivership`) before contracting.
- **Ireland is a major EU corporate, holding and multinational-HQ domicile** - a huge share of tech,
  pharma and finance groups have Irish entities; this verifies them against the official source.
- **Enrichment** - registered address and email in one call.
- **Compliance signal** - the annual-return-due date flags entities that may be late filing.

### What the register does NOT contain here

Stated plainly:

- **No directors, shareholders or beneficial owners.**
- **No filed documents / accounts.**

CRO releases those as **paid documents**. This actor returns the public company record and invents
nothing. For directors or ownership, this is a **verification and enrichment** tool, not a full
ownership profile.

### One number, more than one entity

Irish companies and **business names** are numbered in separate sequences, so the same number can
belong to two different entities: `104547` is both `RYANAIR DESIGNATED ACTIVITY COMPANY` (a DAC
company) and `HOMECARE & INDUSTRIAL CLEANING` (a business name). A number lookup returns both, with
`companyType` telling them apart — that is correct, not duplication.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `companyNames` | array | - | Company names to search, each looked up separately (min 2 chars) |
| `companyNumbers` | array | - | CRO numbers, digits (e.g. `104547`) |
| `maxResultsPerQuery` | integer | 50 | Max records per query (50 is the register's ceiling) |
| `statusFilter` | array | - | Keep only companies whose status contains one of these words (e.g. `Normal`, `Dissolved`) |

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

#### Example input

```json
{
  "companyNames": ["RYANAIR"],
  "statusFilter": ["Normal"],
  "maxResultsPerQuery": 10
}
````

### Result ceiling

A name search returns **at most 50 matches**. When a query hits that ceiling the run says so; narrow
the name or search by number to reach the rest. The full record for every match is fetched in the
same run.

### Billing

Charged **per search**, not per company - one query is served by a single session that runs the
search and fetches every matched company's full record, so the cost is per search regardless of how
many companies come back.

A search that finds nothing is still an answer, and is charged (`lookupStatus:
not_found_in_register`) - "this company is not on the Irish register" is a real KYB result. Queries
that could **not** be retrieved are **not charged**, are absent from the dataset, and are listed in
`FAILED_INPUTS` in the run's key-value store.

### Limitations

- **No directors, shareholders, owners or documents** - paid CRO services (see above).
- **50 results per name search** - a register limit.
- **Status text is the register's own** (`Normal`, `Dissolved`, `Liquidation`, ...).
- **`registeredEmail` is present only when the company filed one** - often null for older entities.

### Related registry actors

Part of a fleet of official-registry actors across 13+ 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), Portugal, Slovakia (RPVS beneficial
owners), Czechia, UAE and California.

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

***

**Data source:** [CRO CORE](https://core.cro.ie/), Companies Registration Office, Ireland. This actor
is not affiliated with or endorsed by the CRO.

# Actor input Schema

## `companyNames` (type: `array`):

One or more company names to search, each looked up separately (min 2 characters). Partial names work. A broad name can hit the register's 50-result ceiling.

## `companyNumbers` (type: `array`):

One or more Irish CRO registration numbers, each looked up separately. Digits only, e.g. '104547'.

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

Maximum company records to export per query. The register returns at most 50 matches per search, so 50 is the ceiling. Fetching the full record for each match happens in the same run.

## `statusFilter` (type: `array`):

Keep only companies whose status contains one of these words, e.g. 'Normal', 'Dissolved', 'Liquidation'. Leave empty to export every match - a Dissolved or Liquidation counterparty is usually the finding you most want to see.

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

Leave this off. A normal run does not need a proxy.

## Actor input object example

```json
{
  "companyNames": [
    "RYANAIR"
  ],
  "maxResultsPerQuery": 10,
  "statusFilter": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `companies` (type: `string`):

Company records from the CRO register 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 = {
    "companyNames": [
        "RYANAIR"
    ],
    "maxResultsPerQuery": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("regdata/ireland-cro-company-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 = {
    "companyNames": ["RYANAIR"],
    "maxResultsPerQuery": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("regdata/ireland-cro-company-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 '{
  "companyNames": [
    "RYANAIR"
  ],
  "maxResultsPerQuery": 10
}' |
apify call regdata/ireland-cro-company-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ireland Company Registry Scraper - CRO",
        "description": "Search the official Irish company register (CRO) by name or number. Returns registered name, CRO number, type, status, incorporation date, registered address and email. No API key.",
        "version": "1.1",
        "x-build-id": "iTw4Y5etLUW2A8cAi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/regdata~ireland-cro-company-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-regdata-ireland-cro-company-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~ireland-cro-company-scraper/runs": {
            "post": {
                "operationId": "runs-sync-regdata-ireland-cro-company-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~ireland-cro-company-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-regdata-ireland-cro-company-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": {
                    "companyNames": {
                        "title": "Company names",
                        "type": "array",
                        "description": "One or more company names to search, each looked up separately (min 2 characters). Partial names work. A broad name can hit the register's 50-result ceiling.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyNumbers": {
                        "title": "Company numbers",
                        "type": "array",
                        "description": "One or more Irish CRO registration numbers, each looked up separately. Digits only, e.g. '104547'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum company records to export per query. The register returns at most 50 matches per search, so 50 is the ceiling. Fetching the full record for each match happens in the same run.",
                        "default": 50
                    },
                    "statusFilter": {
                        "title": "Status filter",
                        "type": "array",
                        "description": "Keep only companies whose status contains one of these words, e.g. 'Normal', 'Dissolved', 'Liquidation'. Leave empty to export every match - a Dissolved or Liquidation counterparty is usually the finding you most want to see.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "proxyConfiguration": {
                        "title": "Proxy (optional)",
                        "type": "object",
                        "description": "Leave this off. 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```