# Russian Software Registry Check by INN (`isolovyev/ru-software-registry-check`) Actor

Check whether a company (by INN) or a software product (by name) is listed in the Unified Register of Russian Programs for Electronic Computers and Databases, with registry number, class and registration date.

- **URL**: https://apify.com/isolovyev/ru-software-registry-check.md
- **Developed by:** [Ivan Solovyev](https://apify.com/isolovyev) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 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/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

## 🏛️ Russian Software Registry Check by INN - with applicant due-diligence

<table width="100%">
<tr>
<td style="padding:24px 28px;background:#EEF2FF;border:1px solid #C7D2FE;border-top:4px solid #4F46E5;border-radius:12px">
<span style="font-size:23px;font-weight:800;color:#1E1B4B;line-height:1.3">Is this software in the Russian Software Registry - and does its right holder actually qualify?</span><br>
<span style="font-size:15px;color:#4B5563;line-height:1.6">Check any INN or product name against the Unified Register of Russian Programs, then get an open-data dossier on the right holder mapped to the register's own eligibility criteria: foreign participation share, IT profile, financials and risk. Signals, never a verdict.</span>
</td>
</tr>
</table>

<table width="100%">
<tr>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #E0E7FF;border-radius:10px 0 0 10px;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#4338CA">🏛️ Registry check</span><br>
<span style="font-size:12px;color:#57534E">Entry number, software class, date and right holder per product</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #E0E7FF;border-left:none;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#4338CA">🌍 Foreign participation</span><br>
<span style="font-size:12px;color:#57534E">Real founder shares and citizenship, read from the ЕГРЮЛ statement</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #E0E7FF;border-left:none;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#4338CA">💵 Financials & risk</span><br>
<span style="font-size:12px;color:#57534E">Revenue, profit, bankruptcy, RNP, Rosfinmonitoring, scored</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #E0E7FF;border-left:none;border-radius:0 10px 10px 0;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#4338CA">🚦 Eligibility signals</span><br>
<span style="font-size:12px;color:#57534E">green / amber / red per criterion, with an honest unknown</span>
</td>
</tr>
</table>

The Unified Register of Russian Programs ([reestr.digital.gov.ru](https://reestr.digital.gov.ru)) is what
confirms a supplier's software counts as domestic under 44-ФЗ / 223-ФЗ import-substitution rules. This Actor
answers both halves of the question: **is the product listed**, and **does the right holder look like it meets
the criteria** the register applies to applicants.

### 🚀 How to use

<table width="100%">
<tr>
<td style="padding:16px 14px;width:33%;background:#EEF2FF;border:1px solid #C7D2FE;border-radius:10px 0 0 10px;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#4F46E5;letter-spacing:1px">STEP 1</span><br>
<span style="font-size:14px;font-weight:700;color:#1E1B4B">Feed INNs or product names</span><br>
<span style="font-size:12px;color:#4B5563">A supplier list, or a product you want to trace to its right holder.</span>
</td>
<td style="padding:16px 14px;width:33%;background:#EEF2FF;border:1px solid #C7D2FE;border-left:none;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#4F46E5;letter-spacing:1px">STEP 2</span><br>
<span style="font-size:14px;font-weight:700;color:#1E1B4B">Run with enrichment</span><br>
<span style="font-size:12px;color:#4B5563">Or turn it off for a cheap registry-only lookup.</span>
</td>
<td style="padding:16px 14px;width:34%;background:#EEF2FF;border:1px solid #C7D2FE;border-left:none;border-radius:0 10px 10px 0;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#4F46E5;letter-spacing:1px">STEP 3</span><br>
<span style="font-size:14px;font-weight:700;color:#1E1B4B">Read the signals</span><br>
<span style="font-size:12px;color:#4B5563">One row per query: registry entries, dossier and per-criterion signals.</span>
</td>
</tr>
</table>

### ✨ What it does

- **By INN** - returns every register entry belonging to that right holder.
- **By product name** - finds matches, resolves the right holder's INN from the entry card, and with
  `expandRightHolder` returns that holder's whole portfolio in the register.
- **By software class** - enumerates a whole register category (for example `06.09`, or the entire
  `06` group) and returns every right holder that has a product in it, grouped by company. Use it
  for market research when the product names are not known upfront.
- **Per unique right holder INN** - with `enrichRightHolder=true`, adds an open-data dossier and a set of
  preliminary eligibility signals.

### ⚙️ Input

| Field | Description |
|---|---|
| `inns` | Right holder INNs: 10 digits for an organization, 12 for an individual / sole proprietor |
| `productNames` | Optional product name(s) to search when the right holder's INN is unknown |
| `maxMatchesPerName` | Max matches fetched per product name (default 10) |
| `softwareClasses` | Optional register classifier codes to enumerate in full, e.g. `06.09` or the whole `06` group |
| `maxProductsPerClass` | Cap on products taken per class (default 100) |
| `expandRightHolder` | For a name search, also return the resolved right holder's full register portfolio |
| `enrichRightHolder` | Default `true`. Collect the applicant dossier and signals. Set `false` for the registry-only mode at a lower run cost |
| `proxyConfiguration` | Apify Residential proxy, country RU - the Russian state sources require a Russian IP |

### 📤 Output

One Dataset record per query, with the register fields: `queryType`, `query`, `inn`, `inRegistry`,
`softwareProducts`, `matchedProducts`, `rightHolder`, `scrapedAt`, `sources`, `sourceErrors`, `partial`.

With enrichment on and the right holder's INN resolved, the record also carries:

- **`rightHolderDossier`** - `ownerType`, `citizenship`, `legalName`, `status`, `opf`, `ogrn`, `kpp`,
  `registeredAt`, `address`,
  `region`, `okvedPrimary`, `itProfile`, `director`, `founders`, `foundersParseIncomplete`,
  `foundersShareSumPct`, `foreignParticipationPct`, `foundersAccessRestricted`, `foundersNotInEgrul`,
  `foreignFoundersPresent`, `foreignControlFlag`, `revenue`, `netProfit`, `financialsYear`,
  `bankruptcyFlag`, `rnpFlag`, `rosfinFlag`, `taxArrearsFlag`, `massAddressFlag`, `massFounderFlag`,
  `riskScore`, `riskLevel`, `riskFactors`.
- **`registryEligibilitySignals`** - `russianEntity`, `activeEntity`, `foreignParticipationOk`,
  `itProfile`, `financiallyActive`, `notBankrupt`, `notInRnp`, `notInRosfin`, `overall`.

`founders[].type` is one of `ru_ul`, `ru_fl`, `foreign_ul`, `foreign_fl` or `null`. `sharePct` and
`foreignParticipationPct` come from the ЕГРЮЛ statement: the sum of confirmed **direct** shares held by
foreign-type participants. Nothing is estimated - if a share or a participant's type is not stated, the field
stays `null` and the signal becomes `unknown`. `foreignControlFlag` is `true` only on a confirmed direct
foreign share above 50%.

`ownerType` is `individual` for a 12-digit INN, `organization` for a 10-digit INN, and `null` for
an unrecognized format. For an individual right holder, `citizenship` is read directly from the software
registry entry. The citizenship criterion is used instead of a capital-share calculation:
`russianEntity` and `foreignParticipationOk` are positive for Russian citizenship, negative for another
stated citizenship, and `unknown` when citizenship is absent. `foreignParticipationPct` remains `null`
because an individual has no capital share. For an organization, the existing foreign-participation rule
based on direct ownership shares is unchanged.

### 🚦 How to read the signals

`overall` has three values:

- **`green`** - the available open data showed no negative signals.
- **`amber`** - some data is missing, needs documents, or the primary OKVED gave no clear IT signal.
- **`red`** - open data showed an inactive status, a confirmed foreign share above 50%, bankruptcy or an
  intention notice, an RNP entry, or a Rosfinmonitoring listing.

### 🗺️ Coverage and limits

Read this before you rely on the foreign-participation figure. These limits are inherent to the open sources,
not to the Actor:

- **Joint-stock companies (АО)** - shareholders are not published in ЕГРЮЛ at all, so
  `foundersNotInEgrul=true` and the foreign-participation signal is `unknown`.
- **Restricted disclosure (129-ФЗ)** - some companies have the participants section closed. Then
  `foundersAccessRestricted=true` and the signal is `unknown`.
- **Indirect ownership** - open data does not expose ownership chains behind a Russian legal-entity
  participant, so `foreignParticipationOk` is never turned positive on that basis alone.
- **Incomplete parse guard** - `foundersShareSumPct` carries the sum of the direct shares read. If
  participants exist but a share is unreadable or the sum falls outside 99..101, the Actor sets
  `foundersParseIncomplete=true`, marks the record `partial`, and returns `unknown` rather than a positive
  signal. A green signal is never issued on an incomplete parse.
- **Payments abroad and infrastructure** - not derivable from open data at all; the applicant evidences these
  with documents.

The financial block returns the latest available revenue and net profit from public reporting.

### 👥 Для кого

| Вы… | Используйте, чтобы… |
|---|---|
| Правообладатель, готовящий заявку | заранее увидеть слабые места, которые проверит экспертиза |
| Консультант по включению в реестр | быстро отсеивать заявителей без шансов и не тратить месяцы |
| Закупщик по 44-ФЗ / 223-ФЗ | подтвердить, что ПО поставщика в реестре, и оценить самого поставщика |
| Аналитик рынка ПО | строить срез по правообладателям реестра и их состоянию |

### ▶️ Quick start

Check a supplier list by INN, with the applicant dossier:

```json
{
  "inns": ["6671080943", "5407163618"],
  "enrichRightHolder": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "RU" }
}
````

Trace a product to its right holder and pull their whole portfolio:

```json
{
  "productNames": ["офисный пакет"],
  "maxMatchesPerName": 10,
  "expandRightHolder": true,
  "enrichRightHolder": false
}
```

Research a whole register category and get the companies behind it:

```json
{
  "softwareClasses": ["06.09"],
  "maxProductsPerClass": 100,
  "expandRightHolder": true,
  "enrichRightHolder": true
}
```

### ⚠️ Important disclaimer

These are **signals from open data for a preliminary assessment - not a legal verdict and not a decision on
inclusion in the register**. The decision is made by the Expert Council of the Ministry of Digital Development.
The applicant evidences payments abroad, infrastructure and other conditions that do not follow reliably from
open sources.

### 🇷🇺 RU / На русском

**Проверяет, есть ли программный продукт в Едином реестре российского ПО (по ИНН правообладателя или
названию продукта), и собирает досье на самого заявителя по открытым данным - под критерии, которые
проверяет экспертиза.**

- **Доля иностранного участия** - реальные доли и гражданство участников из выписки ЕГРЮЛ, а не оценка.
  Считается только подтверждённое **прямое** участие; `foreignControlFlag=true` лишь при доле свыше 50%.
- **Досье заявителя** - юрлицо, статус, ОГРН, ОКВЭД и ИТ-профиль, директор, выручка и прибыль,
  банкротство, РНП, перечень Росфинмониторинга, риск-скоринг с перечнем сработавших факторов.
- **Честная неопределённость** - у АО акционеров в ЕГРЮЛ нет, у части компаний доступ закрыт по 129-ФЗ,
  косвенное владение открытые данные не раскрывают. Во всех этих случаях актор возвращает `unknown`
  с указанием причины, а не выдаёт ложный положительный сигнал. Сумма долей обязана сойтись в 100%:
  не сошлась - разбор считается неполным, и положительный сигнал не выдаётся.
- Выплаты за рубеж и инфраструктуру по открытым данным установить нельзя - это подтверждает заявитель
  документами.

Это **сигналы для предварительной оценки, а не вердикт**: решение о включении в реестр принимает
Экспертный совет Минцифры.

### 🔗 Все наши акторы для данных по России, Казахстану и СНГ

<span style="font-size:14px;color:#4B5563">Одна линейка для маркетплейсов, госзакупок и проверки контрагентов - соседний актор открывается одним кликом по карточке.</span>

<table width="100%">
<tr>
<td style="padding:0;width:16%;background:#FFFFFF;border:1px solid #E0E7FF;border-top:3px solid #4F46E5;border-radius:10px 0 0 10px;vertical-align:top">
<a href="https://apify.com/isolovyev/marketplace-seller-leads" style="display:block;padding:14px 12px;text-decoration:none">
<span style="font-size:13px;font-weight:800;color:#4338CA">🛍️ Лиды продавцов маркетплейсов</span><br>
<span style="font-size:11px;color:#57534E">продавцы WB / Ozon / Яндекс.Маркет / Kaspi с ИНН и ОГРН</span>
</a>
</td>
<td style="padding:0;width:16%;background:#FFFFFF;border:1px solid #E0E7FF;border-left:none;border-top:3px solid #4F46E5;vertical-align:top">
<a href="https://apify.com/isolovyev/zakupki-tender-monitor" style="display:block;padding:14px 12px;text-decoration:none">
<span style="font-size:13px;font-weight:800;color:#4338CA">📄 Тендеры 44-ФЗ / 223-ФЗ</span><br>
<span style="font-size:11px;color:#57534E">госзакупки, нацрежим, реестр российского ПО</span>
</a>
</td>
<td style="padding:0;width:16%;background:#FFFFFF;border:1px solid #E0E7FF;border-left:none;border-top:3px solid #4F46E5;vertical-align:top">
<a href="https://apify.com/isolovyev/ru-counterparty-check" style="display:block;padding:14px 12px;text-decoration:none">
<span style="font-size:13px;font-weight:800;color:#4338CA">🔍 Проверка контрагента по ИНН</span><br>
<span style="font-size:11px;color:#57534E">5 источников, скоринг риска</span>
</a>
</td>
<td style="padding:0;width:16%;background:#FFFFFF;border:1px solid #E0E7FF;border-left:none;border-top:3px solid #4F46E5;vertical-align:top">
<a href="https://apify.com/isolovyev/ru-marketplaces-price-monitor" style="display:block;padding:14px 12px;text-decoration:none">
<span style="font-size:13px;font-weight:800;color:#4338CA">📈 Цены на маркетплейсах</span><br>
<span style="font-size:11px;color:#57534E">WB / Ozon / Яндекс.Маркет / Avito, трекинг цены</span>
</a>
</td>
<td style="padding:0;width:16%;background:#FFFFFF;border:1px solid #E0E7FF;border-left:none;border-top:3px solid #4F46E5;vertical-align:top">
<a href="https://apify.com/isolovyev/kaspi-price-monitor" style="display:block;padding:14px 12px;text-decoration:none">
<span style="font-size:13px;font-weight:800;color:#4338CA">🇰🇿 Цены и позиции на Kaspi.kz</span><br>
<span style="font-size:11px;color:#57534E">Казахстан, позиция в выдаче и цена</span>
</a>
</td>
<td style="padding:14px 12px;width:16%;background:#EEF2FF;border:1px solid #C7D2FE;border-left:none;border-top:3px solid #4F46E5;border-radius:0 10px 10px 0;vertical-align:top">
<span style="font-size:13px;font-weight:800;color:#1E1B4B">🏛️ Реестр российского ПО</span><br>
<span style="font-size:11px;color:#57534E">проверка по ИНН + досье заявителя</span><br>
<span style="font-size:10px;font-weight:800;color:#4F46E5;letter-spacing:0.5px">● ВЫ ЗДЕСЬ</span>
</td>
</tr>
</table>

### 💬 Вопросы и поддержка

Нашли ошибку или есть вопрос? Откройте тикет на вкладке **Issues** этого актора.

# Actor input Schema

## `inns` (type: `array`):

Right holder INN (10 digits for an organization, 12 for an individual/sole proprietor). Exact-match key on the registry - the recommended way to check a known supplier.

## `productNames` (type: `array`):

Software product name to search when you don't have the right holder's INN. Substring match. For each match the actor resolves the right holder and, unless disabled, returns that company's full registry portfolio.

## `softwareClasses` (type: `array`):

Registry classifier codes to enumerate in full, e.g. '06.09' for a single class or '06' for the whole group. Returns every right holder that has a product in the class, grouped by company, with the same dossier as an INN query. Use it for category research when you do not know the names upfront.

## `maxMatchesPerName` (type: `integer`):

For each entry in 'Product names', how many matching registry entries to fetch a right-holder INN for.

## `maxProductsPerClass` (type: `integer`):

Safety cap on how many registry products to take per class. A class can hold hundreds of products, and each one costs an extra request plus a result.

## `expandRightHolder` (type: `boolean`):

For product-name searches, after resolving the right holder also return all of that company's products in the registry (matchedProducts stays the specific match). Turn off for a lighter match-only result.

## `enrichRightHolder` (type: `boolean`):

Collect public-source applicant signals for each resolved registry right holder. Disable to keep the previous registry-only behavior and reduce run cost.

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

Required on Apify: set proxyConfiguration to Apify Residential proxy with country RU. All sources require a Russian IP.

## Actor input object example

```json
{
  "inns": [
    "6671080943"
  ],
  "softwareClasses": [
    "06.09"
  ],
  "maxMatchesPerName": 10,
  "maxProductsPerClass": 100,
  "expandRightHolder": true,
  "enrichRightHolder": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}
```

# 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 = {
    "inns": [
        "6671080943"
    ],
    "softwareClasses": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "RU"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("isolovyev/ru-software-registry-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 = {
    "inns": ["6671080943"],
    "softwareClasses": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "RU",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("isolovyev/ru-software-registry-check").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 '{
  "inns": [
    "6671080943"
  ],
  "softwareClasses": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}' |
apify call isolovyev/ru-software-registry-check --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=isolovyev/ru-software-registry-check",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Russian Software Registry Check by INN",
        "description": "Check whether a company (by INN) or a software product (by name) is listed in the Unified Register of Russian Programs for Electronic Computers and Databases, with registry number, class and registration date.",
        "version": "0.1",
        "x-build-id": "qqUcpTztFJo6ZVK3G"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/isolovyev~ru-software-registry-check/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-isolovyev-ru-software-registry-check",
                "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/isolovyev~ru-software-registry-check/runs": {
            "post": {
                "operationId": "runs-sync-isolovyev-ru-software-registry-check",
                "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/isolovyev~ru-software-registry-check/run-sync": {
            "post": {
                "operationId": "run-sync-isolovyev-ru-software-registry-check",
                "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": {
                    "inns": {
                        "title": "Company INNs",
                        "type": "array",
                        "description": "Right holder INN (10 digits for an organization, 12 for an individual/sole proprietor). Exact-match key on the registry - the recommended way to check a known supplier.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productNames": {
                        "title": "Product names (optional)",
                        "type": "array",
                        "description": "Software product name to search when you don't have the right holder's INN. Substring match. For each match the actor resolves the right holder and, unless disabled, returns that company's full registry portfolio.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "softwareClasses": {
                        "title": "Software classes (optional)",
                        "type": "array",
                        "description": "Registry classifier codes to enumerate in full, e.g. '06.09' for a single class or '06' for the whole group. Returns every right holder that has a product in the class, grouped by company, with the same dossier as an INN query. Use it for category research when you do not know the names upfront.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxMatchesPerName": {
                        "title": "Max matches per product name",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "For each entry in 'Product names', how many matching registry entries to fetch a right-holder INN for.",
                        "default": 10
                    },
                    "maxProductsPerClass": {
                        "title": "Max products per class",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Safety cap on how many registry products to take per class. A class can hold hundreds of products, and each one costs an extra request plus a result.",
                        "default": 100
                    },
                    "expandRightHolder": {
                        "title": "Expand right holder portfolio",
                        "type": "boolean",
                        "description": "For product-name searches, after resolving the right holder also return all of that company's products in the registry (matchedProducts stays the specific match). Turn off for a lighter match-only result.",
                        "default": true
                    },
                    "enrichRightHolder": {
                        "title": "Enrich right holder dossier",
                        "type": "boolean",
                        "description": "Collect public-source applicant signals for each resolved registry right holder. Disable to keep the previous registry-only behavior and reduce run cost.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Required on Apify: set proxyConfiguration to Apify Residential proxy with country RU. All sources require a Russian IP.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "RU"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```