# Company Screening API - Sanctions, Ownership, Risk (`nabeelbaghoor/company-screening-risk-api`) Actor

Search a global corporate registry and risk graph for companies, people, vessels and trade entities. Filter by country, entity type, sanctions, export controls, forced labor and adverse media. Pay per result. Bring your own API key.

- **URL**: https://apify.com/nabeelbaghoor/company-screening-risk-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** Business, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$15.00 / 1,000 entity results

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/platform/actors/running/actors-in-store#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

## Company Screening API - Sanctions, Ownership, Risk

Search a global corporate registry and risk intelligence graph and export the matches as clean rows. Look up a company, a person, a vessel, an aircraft or a trade shipment by name, registration number, address or contact detail, then narrow by country, entity type and the risk signals that matter: sanctions, export controls, forced labor, adverse media, environmental risk, political exposure and regulatory action. You pay only for the entities you actually receive.

This actor is built for sanctions and watchlist screening, third-party and supplier due diligence, know-your-business onboarding checks, and mapping who a counterparty is connected to across jurisdictions.

### What you can do with it

- Screen a counterparty name against sanctions and export control listings.
- Build a list of every entity in a country carrying a forced labor or adverse media signal.
- Check whether a company or one of its officers is politically exposed.
- Pull registry identifiers, addresses and registration dates for entities in a jurisdiction.
- Find entities inside a geographic bounding box, for example around a port or an industrial zone.
- Export everything as JSON, CSV or Excel, or push it into a compliance case management system.

### Features

- Every documented search filter is a real input field: country, source country, state, city, entity type, risk factor, risk category, source and geographic bounds.
- Free-text search can be restricted to name, identifier, address, business purpose, date of birth or contact, so a registration number does not match a street number.
- Advanced query mode passes boolean operators, quoted phrases and field-scoped terms straight through.
- Offset pagination is walked automatically, advancing by the number of records actually returned so a short page can never skip a match.
- The provider's 10,000-result search ceiling is honoured explicitly, with a log line telling you to narrow the filters rather than silently truncating.
- Nested attribute collections such as addresses, countries, contacts and identifiers are flattened into readable arrays, with the first value promoted to its own column.
- Risk factors, relationship counts and source counts are summarised into sortable columns, and the full breakdown is kept alongside them.
- Access tokens are fetched, cached and refreshed automatically, including one silent retry if a token expires mid-run.
- Rate limits are handled with retry-after aware backoff, and a run that hits a limit keeps everything already collected.
- The untouched provider payload is kept under `raw`, so nothing is lost.
- Pay-per-result pricing with a hard result cap so a run can never surprise you.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `query` | string | Name, identifier, address, phone or other free text to search for. |
| `queryFields` | array | Restrict the query to name, identifier, address, business purpose, date of birth or contact. |
| `advanced` | boolean | Treat the query as an advanced expression with boolean operators. |
| `entityType` | array | Company, person, government organization, vessel, aircraft, shipment and more. |
| `country` | array | Three-letter country codes the entity is linked to. |
| `sourceCountry` | array | Three-letter country codes of the underlying record sources. |
| `state` / `city` | array | State or province and city names. |
| `riskCategory` | array | Sanctions, export controls, forced labor, adverse media, environmental risk, political exposure, regulatory action. |
| `risk` | array | Specific risk factor identifiers, narrower than a whole category. |
| `source` | array | Restrict matches to given source identifiers. |
| `bounds` | array | Bounding boxes as `north,west,south,east`. |
| `rawFilter` | object | Any extra filter, merged last. |
| `maxResults` | integer | Stop after this many entities (1 to 10,000). |
| `pageSize` | integer | Entities per API call (1 to 100). |
| `apiKey` | string | Your API client id. Required, stored securely. |
| `apiSecret` | string | Your API client secret. Required, stored securely. |

A query, at least one filter, or both are required.

### Example output

Each dataset item is one entity. Fields are populated where the provider has data, and the untouched payload is kept under `raw`:

```json
{
  "id": "kgQ8vXmT2p9Lb4RcW7yNfA",
  "name": "Example Trading Company Limited",
  "entityType": "company",
  "country": "HKG",
  "countries": ["HKG", "CHN"],
  "address": "Unit 12, 88 Example Road, Kowloon, Hong Kong",
  "addresses": ["Unit 12, 88 Example Road, Kowloon, Hong Kong"],
  "identifiers": [
    { "value": "1234567", "type": "hk_company_number", "label": "Company Number" }
  ],
  "businessPurpose": "Wholesale of industrial machinery",
  "companyType": "Private company limited by shares",
  "contacts": ["+852 5550 0188"],
  "dateOfBirth": null,
  "registrationDate": "2011-06-14",
  "status": "active",
  "statusDate": "2026-01-31",
  "closed": false,
  "sanctioned": false,
  "politicallyExposed": false,
  "riskFactors": ["adverse_media", "export_controls"],
  "riskFactorCount": 2,
  "relationshipCount": 14,
  "relationshipsByType": { "has_officer": 4, "shareholder_of": 2, "shipped_to": 8 },
  "sources": ["Hong Kong Companies Registry", "Global Trade Data"],
  "sourceRecordCount": 27,
  "profileUrl": "https://app.sayari.com/entity/kgQ8vXmT2p9Lb4RcW7yNfA",
  "raw": { "id": "kgQ8vXmT2p9Lb4RcW7yNfA", "label": "Example Trading Company Limited" }
}
```

### Pricing and the credit model

This actor uses pay-per-result pricing. You are charged a fixed price for each entity delivered to the dataset, after duplicates are removed. A search that matches nothing costs nothing. Set `maxResults` to cap how many rows a run can collect, and set a run spending limit as a second safety net. Your own provider plan meters its own credits separately.

### Bring your own API key

This actor connects to a third-party corporate registry and risk intelligence provider (Sayari) on your behalf and requires your own provider credentials. Create a client id and client secret in the provider's platform and paste them into the `apiKey` and `apiSecret` inputs. They are stored securely and never logged, and the actor never ships with or shares credentials.

### Frequently asked questions

#### What data does this actor return?

Entity name, id and type, the countries and addresses linked to it, registry identifiers with their type and label, business purpose, company type, contact details, date of birth for people, registration date and current status, whether the entity is closed, sanctioned or politically exposed, the list of risk factors attached to it, how many relationships it has broken down by relationship type, which sources hold records on it and how many, plus a link to the entity profile. Every record also carries the untouched provider payload.

#### What kinds of entity can I search?

Companies, people, government organizations and trade names, plus the physical and legal objects the graph tracks: vessels, aircraft, properties, shipments, contracts, transactions, accounts, securities, intellectual property and legal matters. Use `entityType` to restrict a search to one or several of them.

#### How do I screen a name against sanctions?

Put the name in `query`, set `queryFields` to `name` so a street or a phone number cannot match by accident, and set `riskCategory` to `sanctions` or `sanctions_and_export_control_lists`. Every row that comes back carries a `sanctioned` flag and the full `riskFactors` list, so a hit is visible in one column.

#### What is the difference between country and source country?

`country` filters on the countries the entity itself is linked to, such as where it is registered or operates. `sourceCountry` filters on the jurisdiction of the underlying records, so it answers a different question: which registry or watchlist the evidence came from. They can be combined.

#### Why does the run stop at 10,000 results?

That is the provider's own ceiling for a single search, not an actor limit. The log says so explicitly when it is reached. Narrow the search with an extra filter, for example one country or one entity type at a time, and run again to reach deeper matches.

#### What does advanced query syntax allow?

Boolean operators, quoted phrases and field-scoped terms, following the provider's advanced search grammar. Leave `advanced` off for a plain keyword search, which is the safer default because an unbalanced quote or operator in advanced mode is rejected by the provider.

#### How are nested fields such as addresses handled?

The provider returns them as collections of records rather than plain strings. The actor flattens each collection into an array of readable values and promotes the first one, which is the best supported, into its own column. When a collection has a shape the actor does not recognise, the whole object is kept rather than dropped.

#### How does authentication work?

The provider issues a short-lived access token from a client id and client secret. The actor requests one at the start of the run, caches it until shortly before it expires, and refreshes it automatically. If a token is rejected mid-run it is refreshed once and the request is retried.

#### How does the actor handle rate limits?

It throttles requests, honours the retry-after signal on a rate-limited response, and backs off exponentially. A response saying the account is out of credits stops the run early and keeps everything already collected.

#### How am I charged?

You pay a fixed price per entity returned to the dataset. Duplicates are removed before charging and empty runs cost nothing. Use `maxResults` and the run spending limit to control cost.

#### What output formats are available?

The dataset can be exported as JSON, CSV, Excel, HTML or RSS, or read through the API for pushing into a compliance or case management system.

### Keyword map

sanctions screening api, company screening api, entity screening api, kyb api, know your business api, corporate registry api, beneficial ownership data api, adverse media screening, export control screening api, forced labor supply chain data, pep screening api, politically exposed person check, watchlist screening api, third party risk data api, supplier due diligence data, trade data entity search, vessel ownership data, company identifier lookup, global company registry search, compliance data api.

# Actor input Schema

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

What to search for: a company name, a person name, a registration number, an address or a phone number. Leave empty to search by filters alone.

## `queryFields` (type: `array`):

Limit where the query text is matched. Leave empty to search every field.

## `advanced` (type: `boolean`):

Treat the query as an advanced expression, which supports boolean operators, quoted phrases and field-scoped terms. Leave off for a plain keyword search.

## `entityType` (type: `array`):

Restrict results to these kinds of entity. Leave empty for all types.

## `country` (type: `array`):

Countries the entity itself is linked to, as three-letter codes such as USA, CHN, DEU, GBR.

## `sourceCountry` (type: `array`):

Countries of the underlying record sources, as three-letter codes. Use this to require evidence from a given jurisdiction.

## `state` (type: `array`):

State or province names to match.

## `city` (type: `array`):

City names to match.

## `riskCategory` (type: `array`):

Only return entities carrying a risk signal in these categories.

## `risk` (type: `array`):

Specific risk factor identifiers to require, for a narrower filter than a whole risk category.

## `source` (type: `array`):

Restrict matches to these source identifiers, for example a single registry or watchlist.

## `bounds` (type: `array`):

Bounding boxes as north,west,south,east coordinate strings. Only entities with an address inside a box are returned.

## `rawFilter` (type: `object`):

Any additional filter, merged over the ones above. Values may be a single value or a list. Use this for a filter the provider adds after this actor was published.

## `maxResults` (type: `integer`):

Stop after this many entity records (1 to 10,000). The provider caps a single search at 10,000 matches. You are charged per result returned.

## `pageSize` (type: `integer`):

How many entities to request per API call (1 to 100). Larger pages mean fewer calls.

## `apiKey` (type: `string`):

Your own client id for the data provider. Required. Used with the client secret below to obtain a short-lived access token. Stored securely and never logged.

## `apiSecret` (type: `string`):

Your own client secret for the data provider. Required. Stored securely and never logged.

## Actor input object example

```json
{
  "query": "acme trading",
  "advanced": false,
  "rawFilter": {},
  "maxResults": 100,
  "pageSize": 100
}
```

# 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": "acme trading",
    "rawFilter": {},
    "maxResults": 100,
    "pageSize": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/company-screening-risk-api").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": "acme trading",
    "rawFilter": {},
    "maxResults": 100,
    "pageSize": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/company-screening-risk-api").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": "acme trading",
  "rawFilter": {},
  "maxResults": 100,
  "pageSize": 100
}' |
apify call nabeelbaghoor/company-screening-risk-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nabeelbaghoor/company-screening-risk-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/CNeweSwNFILLExiFk/builds/3TugTpRanKdSjJTZc/openapi.json