# Russia EGRUL Business Registry Scraper (`pan_kowych/egrul-scraper`) Actor

Search Russia's official FNS EGRUL registry by INN, OGRN, OGRNIP, company name, or entrepreneur name. Export structured company records for KYC, supplier verification, due diligence, counterparty checks, and registry enrichment.

- **URL**: https://apify.com/pan\_kowych/egrul-scraper.md
- **Developed by:** [Vladislav Rodikov](https://apify.com/pan_kowych) (community)
- **Categories:** MCP servers, Lead generation, Other
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Russia EGRUL Business Registry Scraper

Search Russia's official FNS EGRUL business registry by INN, OGRN, OGRNIP, company name, or entrepreneur name. Export structured company records for KYC, supplier verification, due diligence, counterparty checks, compliance workflows, and registry enrichment.

EGRUL is Russia's official business registry maintained by the Federal Tax Service. This Actor turns public registry lookups into clean Apify dataset rows with company identifiers, legal names, addresses, management details, OKVED activity codes, registration status, source links, and official extract links when available.

### Pricing

Pay per event + usage. Result: **$5.00 / 1,000 results**. Actor start: **$0.00005**. Platform usage is charged by Apify separately.

### What it does

- Searches the official FNS EGRUL registry for Russian legal entities and sole entrepreneurs.
- Looks up companies by INN, OGRN, OGRNIP, company name, or entrepreneur name.
- Processes one query or a batch of registry lookups in a single run.
- Returns one structured dataset row per matching registry record.
- Exports official identifiers, legal names, CEO/management data, registered address, OKVED activity, registration date, and status.
- Keeps source URLs and official extract PDF URLs for audit trails.
- Reports captcha, timeout, not found, and upstream failures as diagnostic rows instead of silent empty success.

### Who uses it

- Compliance teams running KYC, KYB, sanctions, and counterparty checks.
- Procurement and supplier onboarding teams verifying Russian vendors.
- Due diligence teams validating legal status, address, CEO, and registration details.
- Data teams enriching CRM, ERP, vendor, and risk databases with official registry fields.
- Researchers and investigative teams building source-backed company datasets.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `query` | string | One INN, OGRN, OGRNIP, company name, or entrepreneur name. |
| `queries` | string array | Batch of lookup values. If `query` is also set, it is processed first. |
| `entityType` | enum | `ul` for legal entities, `ip` for sole entrepreneurs, `ulip` for both. |
| `maxItems` | integer | Maximum rows to return per query. |
| `includeExtract` | boolean | Download and parse official EGRUL extract data when available. Default: `true`. |
| `includeRaw` | boolean | Include raw source payloads. Default: `false`. |
| `diagnostics` | boolean | Emit diagnostic rows for captcha, not found, timeout, and upstream errors. Default: `true`. |

### Examples

Lookup by INN:

```json
{
  "query": "7707083893",
  "entityType": "ul",
  "maxItems": 10,
  "includeExtract": true,
  "includeRaw": false,
  "diagnostics": true
}
````

Batch lookup:

```json
{
  "queries": ["7707083893", "1027700132195", "GAZPROM"],
  "entityType": "ulip",
  "maxItems": 5,
  "includeExtract": true
}
```

### Output

Each dataset row is one EGRUL registry result.

| Field | Description |
| --- | --- |
| `query` | Original lookup value. |
| `entityType` | Registry entity type requested or returned. |
| `inn` | Russian taxpayer identifier. |
| `ogrn` | Primary state registration number for legal entities. |
| `ogrnip` | State registration number for sole entrepreneurs. |
| `kpp` | Tax registration reason code when available. |
| `companyName` | Short company or entrepreneur display name. |
| `fullName` | Full official legal name. |
| `ceo`, `ceoName`, `ceoPosition` | Management fields when available. |
| `address`, `regionName` | Registered address and region. |
| `activityCode`, `activityName` | OKVED activity code and name. |
| `registrationDate` | Registry registration date. |
| `status` | Current registry status when available. |
| `sourceUrl` | Official FNS search URL. |
| `extractPdfUrl` | Official extract document URL when available. |
| `scrapedAt` | Timestamp when the row was collected. |
| `error` | Diagnostic error code/message for upstream issues. |

When `includeExtract=true`, additional official registry details are stored under `egrul.extract`, including identity, address, management, charter capital, OKVED activities, founders, licenses, branches, tax/fund registrations, reorganization, and history sections when present in the official extract.

Sample record:

```json
{
  "query": "7707083893",
  "entityType": "ul",
  "inn": "7707083893",
  "ogrn": "1027700132195",
  "kpp": "773601001",
  "companyName": "PAO SBERBANK",
  "fullName": "PUBLICHNOE AKTSIONERNOE OBSHCHESTVO SBERBANK ROSSII",
  "ceoName": "German Gref",
  "ceoPosition": "President, Chairman of the Executive Board",
  "address": "Moscow, Russia",
  "regionName": "Moscow",
  "activityCode": "64.19",
  "activityName": "Other monetary intermediation",
  "registrationDate": "2002-08-16",
  "status": "active",
  "sourceUrl": "https://egrul.nalog.ru/index.html",
  "extractPdfUrl": "https://egrul.nalog.ru/vyp-download/example",
  "scrapedAt": "2026-06-26T00:00:05.000Z",
  "error": ""
}
```

### Why choose this Actor

- Official source: data comes from Russia's Federal Tax Service EGRUL registry.
- Built for business checks: useful for KYC, KYB, supplier verification, counterparty checks, due diligence, and registry enrichment.
- Batch ready: submit many INN, OGRN, OGRNIP, or company-name lookups in one run.
- Audit friendly: keeps official source links and extract links when available.
- Automation ready: export CSV, Excel, JSON, JSONL, XML, RSS, or HTML from Apify datasets.
- Integration ready: connect results to APIs, webhooks, schedules, Make, Zapier, Google Sheets, BigQuery, Snowflake, Postgres, or your internal risk system.

### How to use

1. Enter an INN, OGRN, OGRNIP, company name, or entrepreneur name.
2. Choose `entityType`: legal entities, sole entrepreneurs, or both.
3. Set `maxItems` for the number of matches you want per query.
4. Start the Actor and export the dataset in your preferred format.

### Automation

Use this Actor in scheduled compliance checks, vendor onboarding workflows, lead enrichment pipelines, or registry monitoring jobs. Apify datasets and integrations let you send the results to spreadsheets, databases, BI tools, webhooks, or downstream screening systems.

### FAQ

**Is the data official?**\
Yes. The Actor searches the public EGRUL registry maintained by Russia's Federal Tax Service.

**Can I search by company name?**\
Yes. You can search by INN, OGRN, OGRNIP, company name, or entrepreneur name.

**Does it support sole entrepreneurs?**\
Yes. Set `entityType` to `ip` for sole entrepreneurs or `ulip` for both companies and sole entrepreneurs.

**What happens if FNS blocks or times out?**\
With `diagnostics=true`, captcha, timeout, not found, and upstream errors are returned as diagnostic dataset rows.

**Can I run batch checks?**\
Yes. Use the `queries` array to process multiple lookups in one Actor run.

**What can I export?**\
Apify datasets can be exported as CSV, Excel, JSON, JSONL, XML, RSS, or HTML.

### Disclaimer

This Actor collects publicly available registry information from official public sources. Users are responsible for ensuring that their use of the data complies with applicable laws, platform rules, and source terms.

# Actor input Schema

## `query` (type: `string`):

INN, OGRN, OGRNIP, or company / entrepreneur name.

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

Optional batch of INN, OGRN, OGRNIP, or names. If query is also set, it is processed first.

## `entityType` (type: `string`):

Legal entity, sole entrepreneur, or both.

## `maxItems` (type: `integer`):

Maximum EGRUL rows to return per query.

## `includeExtract` (type: `boolean`):

Download and parse official EGRUL extract data when available.

## `includeRaw` (type: `boolean`):

Include raw EGRUL response / extract text in output. Disabled by default to keep dataset rows compact.

## `diagnostics` (type: `boolean`):

Emit dataset rows for captcha, not found, timeout, and upstream errors.

## Actor input object example

```json
{
  "query": "7707083893",
  "entityType": "ul",
  "maxItems": 10,
  "includeExtract": true,
  "includeRaw": false,
  "diagnostics": true
}
```

# Actor output Schema

## `datasetUrl` (type: `string`):

No description

## `outputUrl` (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 = {
    "query": "7707083893"
};

// Run the Actor and wait for it to finish
const run = await client.actor("pan_kowych/egrul-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 = { "query": "7707083893" }

# Run the Actor and wait for it to finish
run = client.actor("pan_kowych/egrul-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 '{
  "query": "7707083893"
}' |
apify call pan_kowych/egrul-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Russia EGRUL Business Registry Scraper",
        "description": "Search Russia's official FNS EGRUL registry by INN, OGRN, OGRNIP, company name, or entrepreneur name. Export structured company records for KYC, supplier verification, due diligence, counterparty checks, and registry enrichment.",
        "version": "0.4",
        "x-build-id": "mqdScpFoH7grhJqjc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/pan_kowych~egrul-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-pan_kowych-egrul-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/pan_kowych~egrul-scraper/runs": {
            "post": {
                "operationId": "runs-sync-pan_kowych-egrul-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/pan_kowych~egrul-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-pan_kowych-egrul-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": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "INN, OGRN, OGRNIP, or company / entrepreneur name."
                    },
                    "queries": {
                        "title": "Batch queries",
                        "type": "array",
                        "description": "Optional batch of INN, OGRN, OGRNIP, or names. If query is also set, it is processed first.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "entityType": {
                        "title": "Entity type",
                        "enum": [
                            "ul",
                            "ip",
                            "ulip"
                        ],
                        "type": "string",
                        "description": "Legal entity, sole entrepreneur, or both.",
                        "default": "ul"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Maximum EGRUL rows to return per query.",
                        "default": 10
                    },
                    "includeExtract": {
                        "title": "Include official extract",
                        "type": "boolean",
                        "description": "Download and parse official EGRUL extract data when available.",
                        "default": true
                    },
                    "includeRaw": {
                        "title": "Include raw source payloads",
                        "type": "boolean",
                        "description": "Include raw EGRUL response / extract text in output. Disabled by default to keep dataset rows compact.",
                        "default": false
                    },
                    "diagnostics": {
                        "title": "Emit diagnostic rows",
                        "type": "boolean",
                        "description": "Emit dataset rows for captcha, not found, timeout, and upstream errors.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
