# Romanian Company Check: ANAF, VIES, Financials (`deriverge/romanian-company-check`) Actor

Check Romanian companies in bulk against ANAF, the tax authority's live register. Add CUI or VAT numbers and get legal name, address, VAT status, fiscal inactivity and e-Factura registration, plus yearly turnover, profit and headcount. Rows that cannot be matched are free.

- **URL**: https://apify.com/deriverge/romanian-company-check.md
- **Developed by:** [deriverge s.r.o.](https://apify.com/deriverge) (community)
- **Categories:** Business, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 company records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Romanian Company Checker

### What does Romanian Company Checker do?

**Romanian Company Checker** verifies Romanian companies in bulk against ANAF, the Romanian tax authority, straight from its live register. Give it a list of CUIs or VAT numbers and for each one you get back the legal name, address, registry number, VAT status, fiscal inactivity, e-Factura registration, and up to five years of financial statements: net turnover, profit or loss, and average headcount.

The financial history is the part nobody else offers. A company that looks fine on paper but lost money three years running, or slid from 200 employees to 30, tells you something no name-and-address lookup ever will.

- Data comes from ANAF's own web service, the same one the state runs for banks and accountants. No scraping of web pages, no proxies, no headless browser.
- Rows that cannot be matched are **free**. You only pay for entities we actually resolve.
- Typos never reach the register: every CUI is validated against its checksum locally first, and a failed checksum is reported as such, free of charge.

### Why fiscal inactivity matters

Romania has a status called **inactiv fiscal**. A fiscally inactive supplier still legally exists and can still send you invoices, but **you cannot deduct VAT from those invoices**. Pay one and the tax loss is yours. ANAF publishes the status, the activation date and the reactivation date, and this actor turns it into a plain risk flag on the row.

The same goes for removal from the register (radiere), the VAT-on-collection scheme, and disagreements between ANAF and the EU VIES system. Every VAT payer is cross-checked against VIES as a second, independent source, and if the two registers disagree, the row says so instead of picking one silently.

### Natural persons are not companies

The Romanian register also contains sole traders and family businesses under the same identifier scheme, listed by their personal names. This actor tells the two apart using the registry number prefix and the legal form, and **when the entity is a natural person, the name and address are withheld by design**. You still learn that the CUI exists, whether it is active and whether it pays VAT. When the register does not say which it is, the row is marked uncertain rather than guessed.

### Input

```json
{
  "companies": [
    "RO1590082",
    "14399840",
    { "cui": "2816464", "reference": "supplier-42" }
  ],
  "financialYears": 3,
  "includeVies": true
}
```

Strings and objects can be mixed freely. The optional `reference` is returned unchanged so you can join results back to your own system.

### Output

One row per submitted company:

```json
{
  "input": "RO1590082",
  "matched": true,
  "entityType": "legal_entity",
  "cui": "1590082",
  "vatNumber": "RO1590082",
  "name": "OMV PETROM SA",
  "address": "MUN. BUCUREŞTI, SECT. 1, STR. CORALILOR, NR. 22",
  "registryNumber": "J1997008302407",
  "companyActive": true,
  "fiscallyInactive": false,
  "vatPayer": true,
  "vatValidVies": true,
  "eFacturaRegistered": true,
  "financials": [
    { "year": 2025, "netTurnover": 21550000000, "netProfit": 2900000000, "employees": 10500 }
  ],
  "riskFlags": [],
  "provenance": [
    { "source": "ANAF", "sourceUrl": "https://webservicesp.anaf.ro/api/PlatitorTvaRest/v9/tva", "ok": true }
  ]
}
```

Every value carries provenance: which register said it, at which URL, and when. If a source was down, the affected fields are `null` rather than silently wrong, and the provenance row says why.

### Watch a list for changes

Checking a supplier once is useful. Checking the same list every morning and reading only what changed is what keeps you out of trouble. Give the run a watch name (or save it as a task and schedule it) and every later run compares its results with the previous one: a company that turned inactive, a new risk flag, a VAT registration cancelled, a published account that disappeared. The differences are stored in the `CHANGES` record of the run, ready for an integration or an email. The comparison itself is free.

### Pricing

| Event | Price |
|---|---|
| Run fee, charged once per run that resolves at least one company | $0.03 |
| Company resolved | $0.008 |
| Each additional source that returned an answer | $0.003 |
| Company not found | **free** |

### Speed and limits

ANAF accepts batches of hundreds of companies per request, so identity checks are fast even for long lists. Financial statements are one request per company per year and the register asks for one request per second, which the actor respects. As a rule of thumb: identity for 1,000 companies takes about a minute; identity plus three years of financials for the same list takes about an hour. That is the register's pace, not ours, and it is why `financialYears` is a setting rather than always on.

### Frequently asked questions

**What does an unmatched row cost?** Nothing. Rows that fail the CUI checksum or that ANAF does not know are returned with an explanation and are never charged. Years with no filed statement are not charged either.

**Where does the data come from?** ANAF, the Romanian tax authority, through its own web service, plus the EU VIES system as an independent confirmation. Every value carries its source and timestamp.

**Why do some rows have no name?** Because the identifier belongs to a natural person, not a company. Their name and address are withheld by design; you still learn the entity exists, its status and its VAT registration.

**How fresh are the financial statements?** They are the yearly statements companies file with ANAF, typically available a few months after each year ends. The most recent filed year comes first.

### Sources

| Source | What it provides |
|---|---|
| **ANAF** (tax authority) | Identity, VAT registration with full history, fiscal inactivity, e-Factura status, removal from the register |
| **ANAF bilanț** | Yearly financial statements: net turnover, profit or loss, average headcount |
| **EU VIES** | Independent confirmation that the VAT number is valid for cross-border trade |

All sources are official, public and free of charge, which keeps runs cheap and the data authoritative. This is the Romanian sibling of our [Czech & Slovak Company Checker](https://apify.com/deriverge/czech-company-check); the two share the same validation engine and the same billing rule that unmatched rows are free.

# Actor input Schema

## `companies` (type: `array`):

One entry per company: a CUI (1590082), a VAT number (RO1590082), or an object with cui, vatNumber and an optional reference that is returned unchanged. Typos that fail the CUI checksum are reported and never charged.

## `financialYears` (type: `integer`):

How many recent yearly financial statements to attach (net turnover, profit or loss, average headcount). 0 turns financials off. Each year is one extra request per company, so large lists run longer.

## `includeVies` (type: `boolean`):

Cross-check every VAT payer against the EU VIES system as a second, independent source. A disagreement between ANAF and VIES is reported as a risk flag.

## `watchKey` (type: `string`):

Give the run a name such as "suppliers" and schedule it. Every later run with the same name compares its results with the previous one and stores the differences (status changes, new risk flags, removed accounts) in the CHANGES record. Comparison is free. Runs from a saved task are compared automatically even without a name.

## Actor input object example

```json
{
  "companies": [
    "RO1590082",
    {
      "cui": "14399840",
      "reference": "supplier-42"
    }
  ],
  "financialYears": 3,
  "includeVies": true
}
```

# Actor output Schema

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

One row per submitted company, with identity, VAT status, fiscal inactivity, financial history and risk flags.

## `summary` (type: `string`):

How many entities were resolved, how many were not found and therefore not charged, and how many carry a risk flag.

# 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 = {
    "companies": [
        "RO1590082",
        {
            "cui": "14399840",
            "reference": "supplier-42"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("deriverge/romanian-company-check").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 = { "companies": [
        "RO1590082",
        {
            "cui": "14399840",
            "reference": "supplier-42",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("deriverge/romanian-company-check").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "companies": [
    "RO1590082",
    {
      "cui": "14399840",
      "reference": "supplier-42"
    }
  ]
}' |
apify call deriverge/romanian-company-check --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deriverge/romanian-company-check"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/4wWmPXa5tJugBp2GT/builds/FUtFpaRu5E6hXgFfL/openapi.json