# Business Entity Search API — SEC, Companies House & ABN (KYB) (`oneshotventure/entity-search`) Actor

Look up official company records across US SEC EDGAR, UK Companies House and the Australian Business Register in one call. Name, identifier, status, type and registered address as clean JSON for KYB, onboarding and due-diligence. Official registry APIs only. Batch lookups, per-source diagnostics.

- **URL**: https://apify.com/oneshotventure/entity-search.md
- **Developed by:** [Nick](https://apify.com/oneshotventure) (community)
- **Categories:** Lead generation, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Business Entity Search API — SEC, Companies House & ABN (KYB)

Look up **official company records** across three national registries — US SEC EDGAR, UK Companies
House and the Australian Business Register — from a single input. Clean, normalized JSON straight
from government sources: no scraped pages, no resold databases, no cookies, no logins.

### What does this Actor do?

You give it a company name (or a batch of names) and it queries each selected registry's own public
API, then flattens every result into one identical record shape. A UK company, a US SEC filer and an
Australian ABN holder come back as the same ten fields, so you can put them in one table without
writing a mapper per country.

The part that is usually painful is that the three registries disagree about almost everything. SEC
EDGAR indexes filers by CIK and publishes no status field on its name index; Companies House uses an
eight-character company number and a rich status vocabulary; the ABR uses an 11-digit ABN with a
checksum. This Actor handles each on its own terms — the ABN is checksum-validated locally before a
lookup is attempted, so an invalid number fails fast instead of burning a request — and the
`identifierType` input exists precisely because a bare number is ambiguous between a CIK and a UK
company number.

The second design decision worth knowing: **a failing registry never fails your run.** If one source
is down, rate-limited or unconfigured, the other sources still return their rows and the failure is
recorded as a structured diagnostic in the `RUN_SUMMARY` key-value record — never as a junk row in
your paid results.

### Who is it for?

- **KYB and onboarding teams** verifying that a counterparty legally exists before transacting.
- **Compliance and due-diligence analysts** who need the registry's own answer, not a data vendor's
  copy of it.
- **Sales and RevOps teams** grounding CRM company records against an authoritative identifier
  instead of inferring identity from a social profile.
- **Developers** who want one schema for three countries rather than three API integrations.
- **AI agent builders** who need a company-identity tool with a stable, described output shape.

### Use cases

- Confirm a supplier's legal name, registration number and status before approving them as a vendor.
- Resolve a messy CRM company name to an official identifier (CIK, company number or ABN) you can
  key on afterwards.
- Screen a batch of prospects in one run by passing `queries`, and keep the originating query on
  every row so results stay attributable.
- Pull a single company's full record by identifier in `detail` mode to refresh status and address.
- Give an agent a tool that answers "does this company exist, and what is its official identifier?"
  from the registry rather than from training data.

### What you get

One row per matching entity, per registry. Any value the source does not publish is `null` — the
field is always present.

| Field | Type | Description |
|---|---|---|
| `query` | string | The name or identifier that produced this row, so batch results stay attributable |
| `name` | string | Registered legal name as the registry publishes it |
| `jurisdiction` | string | `us-sec`, `uk` or `au` |
| `identifier` | string | CIK (US), company number (UK) or ABN (AU) |
| `status` | string | Registration status where the source publishes it — see the coverage notes below |
| `type` | string | Entity or company type as the registry classifies it |
| `address` | object | Registry address, shape varies by source (see below); `null` where not published |
| `registryUrl` | string | Direct link to the record on the registry's own site |
| `source` | string | `SEC EDGAR`, `Companies House` or `ABN Lookup` |
| `retrievedAt` | string | ISO 8601 timestamp of when this row was fetched |

`address` is an object, not a string, and its keys differ by source: Companies House returns
`{ locality, region, postcode, country }`, while SEC EDGAR detail and ABN Lookup return
`{ state, postcode }`.

#### Sample output record

A `search`-mode result from SEC EDGAR:

```json
{
  "query": "Tesla",
  "name": "Tesla, Inc.",
  "jurisdiction": "us-sec",
  "identifier": "1318605",
  "status": null,
  "type": "SEC-registered filer",
  "address": null,
  "registryUrl": "https://www.sec.gov/edgar/browse/?CIK=1318605",
  "source": "SEC EDGAR",
  "retrievedAt": "2026-08-22T14:37:02.461Z"
}
```

A `detail`-mode result for the same company fills in `status` (SEC entity type), `type` (the SIC
description) and `address`.

### How to use it

#### Search by name across registries

```json
{
  "query": "Tesla",
  "jurisdictions": ["us-sec", "uk"],
  "maxResults": 5,
  "mode": "search"
}
```

#### Batch several names in one run

Provide `queries` instead of `query`. When `queries` is present it replaces `query` entirely, and
every output record carries the `query` that produced it.

```json
{
  "queries": ["Tesla", "BHP", "Unilever"],
  "jurisdictions": ["us-sec", "uk", "au"],
  "maxResults": 5,
  "mode": "search"
}
```

#### Fetch one company's full record by identifier

Switch to `detail` mode and pass the identifier. Set `identifierType` to disambiguate — a bare
number could be a CIK or a UK company number, and `auto` uses conservative format detection that
will decline rather than guess wrong.

```json
{
  "query": "0000320193",
  "identifierType": "cik",
  "mode": "detail"
}
```

### Input parameters

| Input | Type | Description |
|---|---|---|
| `query` | string | A company name for search mode, or a jurisdiction-specific identifier for detail mode |
| `queries` | array | Optional batch. When provided, this list is used instead of `query` |
| `jurisdictions` | array | Which registries to query: `us-sec`, `uk`, `au`. Default: all three |
| `maxResults` | integer | Maximum records returned per registry (1–100). Default: `10` |
| `mode` | string | `search` finds companies by name; `detail` fetches one record by identifier. Default: `search` |
| `identifierType` | string | `cik`, `uk-company-number`, `abn` or `auto`. Disambiguates numeric identifiers in detail mode. Default: `auto` |

You must supply either `query` or a non-empty `queries` array; the run fails with a clear error if
neither is present.

### Coverage, honestly stated

- **us-sec** covers **SEC-registered filers** — public companies and other entities that file with
  the SEC. It is not a register of every US private LLC, and no such single national register
  exists. In `search` mode the SEC name index publishes no status or address, so those fields come
  back `null`; use `detail` mode to fill them.
- **uk** covers the full Companies House register.
- **au** covers Australian Business Register ABN records.
- **Credentials:** SEC EDGAR needs none. Companies House and ABN Lookup require API credentials
  configured on the Actor. If one is unavailable, that source contributes an `UNCONFIGURED`
  diagnostic to `RUN_SUMMARY` and the run continues with the remaining registries rather than
  failing.
- **Name search is name search.** A common name returns several candidates; `maxResults` caps them
  per registry. Confirm the match with the `identifier` and `registryUrl` before acting on it.

### Reliability

Official registry APIs only, with respectful rate limits and structured error codes. Per-source
diagnostics are written to the `RUN_SUMMARY` key-value record — successes with their result counts,
failures with a `reasonCode` and message — and never into your dataset.

Every record carries `retrievedAt` and a `registryUrl` back to the official source, so you can check
any row against the publisher yourself.

Maintained against the upstream APIs. If a registry changes its schema or an endpoint moves, report
it through the Issues tab and it gets fixed.

### Integrations

Connect this Actor to Make, Zapier, n8n, Slack, Google Sheets, Airtable or any HTTP endpoint through
Apify integrations. Every finished run can push its dataset onward or fire a webhook so a downstream
job starts the moment the data lands. Datasets export as JSON, CSV, Excel, XML, RSS or HTML.

### API usage

Run the Actor from your own code with the Apify API:

```bash
curl -X POST "https://api.apify.com/v2/acts/oneshotventure~entity-search/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query": "Tesla", "jurisdictions": ["us-sec", "uk"], "maxResults": 5, "mode": "search"}'
```

Python, JavaScript, PHP and CLI clients are documented under
[Apify API clients](https://docs.apify.com/api/client).

### Use with AI agents (MCP)

This Actor is callable from any MCP-compatible client — Claude, Cursor, VS Code or your own agent —
through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). The input schema is
fully described and every record uses one stable, flat JSON shape, so an agent can call it and read
the result without a parsing step. Because it reads official government registry APIs rather than a
rendered page, the answer an agent gets is the same one the source publishes.

A useful agent pattern: resolve a company name to its official identifier here, then pass that
identifier to [SEC EDGAR Filings Monitor](https://apify.com/oneshotventure/sec-filings) to watch what
it files.

### Frequently asked questions

#### Is there a free company registry API?

The underlying registries are public: SEC EDGAR is open, Companies House and the ABR publish APIs to
registered users. This Actor is the normalization layer over all three — one input, one output
schema, no per-country integration work.

#### How do I verify a company exists across US, UK and Australian registries?

Run it in `search` mode with all three jurisdictions selected. Each registry that has a match returns
a row with its own identifier and a `registryUrl` you can open to confirm.

#### What is KYB, and what does this give me for it?

Know Your Business is the counterparty equivalent of KYC: confirming a business is real, currently
registered, and is who it claims to be before you transact. This Actor supplies the registry-of-record
half of that — legal name, official identifier, status, type and registered address. It does not
perform sanctions screening or beneficial-ownership resolution.

#### Does this cover US private LLCs?

No. `us-sec` is SEC-registered filers only. US private companies are registered at state level with
50 separate Secretaries of State, which this Actor does not query.

#### Do I need a Companies House API key?

Not as a user of this Actor — credentials are configured on the Actor itself. If a registry's
credentials are unavailable at run time, you get the other registries plus an `UNCONFIGURED`
diagnostic in `RUN_SUMMARY` rather than a failed run.

#### Why is `status` empty for my SEC result?

Because you are in `search` mode. The SEC's public company-name index does not carry a status field.
Re-run in `detail` mode with the CIK to get the SEC entity type, SIC description and address.

#### Can I look up many companies at once?

Yes. Pass `queries` as an array. Each result records the `query` that produced it, so you can join
the output back to your input list.

#### Is this data legal to use?

It is public record data published by government registries for exactly this purpose. How you *use*
it remains your responsibility — where a record contains personal data, GDPR and comparable laws
still apply and you need a lawful basis for processing it.

### Related actors

- [SEC EDGAR Filings Monitor](https://apify.com/oneshotventure/sec-filings) — new 10-K, 10-Q, 8-K and
  Form 4 filings for a watchlist of tickers or CIKs.
- [CourtListener RECAP Docket Watch](https://apify.com/oneshotventure/recap-watch) — new federal
  court cases and bankruptcy filings by party name.
- [SAM.gov Contract Opportunities & Awards Feed](https://apify.com/oneshotventure/sam-feed) — US
  federal contract opportunities and awards.

### Disclaimer

Unofficial independent tool. Not affiliated with or endorsed by the SEC, Companies House, or the
Australian Business Register. Data is retrieved from their official public sources.

# Actor input Schema

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

A company name for search mode, or a jurisdiction-specific identifier for detail mode.

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

Optional batch of company names for search mode or jurisdiction-specific identifiers for detail mode. When provided, this list is used instead of query.

## `jurisdictions` (type: `array`):

Which official registries to query. us-sec = SEC EDGAR (US public filers), uk = Companies House, au = Australian Business Register. Default: all three.

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

Maximum records returned per registry (1-100).

## `mode` (type: `string`):

search = find companies by name; detail = fetch one company's full record by identifier (set identifierType).

## `identifierType` (type: `string`):

Required to disambiguate numeric identifiers in detail mode; auto uses conservative format detection.

## Actor input object example

```json
{
  "query": "Tesla",
  "jurisdictions": [
    "us-sec",
    "uk",
    "au"
  ],
  "maxResults": 5,
  "mode": "search",
  "identifierType": "auto"
}
```

# Actor output Schema

## `records` (type: `string`):

Normalized official-registry company records in the default dataset.

## `runSummary` (type: `string`):

Per-source diagnostics (successes, failures with reason codes, query window) stored as RUN\_SUMMARY in the key-value store.

# 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": "Tesla",
    "maxResults": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("oneshotventure/entity-search").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": "Tesla",
    "maxResults": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("oneshotventure/entity-search").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "query": "Tesla",
  "maxResults": 5
}' |
apify call oneshotventure/entity-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,oneshotventure/entity-search"
        }
    }
}

```

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/HNsFd0BQ9fN6MpXWG/builds/0JMrUYRC87hPzx0ZX/openapi.json