# Company Lookup & KYB: Secretary of State Business Entity Search (`cpt_engineering/us-company-lookup-kyb`) Actor

Bulk US company lookup and KYB verification: business entity search in official Secretary of State and state registry data (CO, CT, NY, OR, PA, TX). Tested Oct 17, 2026: 17/17 matched to the right entity, explicit NOT_FOUND for every unregistered name. Match score, status, formation date, ID.

- **URL**: https://apify.com/cpt_engineering/us-company-lookup-kyb.md
- **Developed by:** [Christopher Tolentino](https://apify.com/cpt_engineering) (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

from $2.40 / 1,000 company lookup with a matches

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## US Company Lookup & KYB: Secretary of State Business Entity Search

**Bulk company lookup and business entity search** against official state business registry data (Secretary of State and equivalent agencies) for **Colorado, Connecticut, New York, Oregon, Pennsylvania and Texas**. Paste a list of company names (or state registry IDs) and get **one verification result per company**: whether it is registered, its **status**, **formation date**, **entity type**, **registry ID**, **jurisdiction** and a **link to the official source record**, with a **0-100 match score**.

**Last verified:** 2026-10-16 (daily automated self-test against the live state sources).

### Tested accuracy (Oct 17, 2026, live build, 20 companies across CO, CT, NY, OR, PA, TX)

| | |
|---|---|
| Registry match | **17 of 17** registered companies matched to the right legal entity, including short names such as "M & C Concrete LLC." |
| Not found | **One row per input**: 3 of 3 unregistered names returned an explicit `NOT_FOUND` row (no silent gaps) |
| Texas right to transact | **2 of 2** companies that lost the right to transact flagged `FORFEITED`, even where the Secretary of State shows *Active* |
| Wrong-company matches | A more generic registered name is not offered as a match; every row carries a 0-100 match score and the matched legal name |
| Speed | **~3 s per company** in a batch of 20 |
| Billing | `NOT_FOUND` is **free when a state source fails** |

### What to check in any KYB or lien tool

1. **Expired liens counted as active**: a UCC filing lapses after 5 years unless continued, and can be terminated earlier. "Active" should mean not terminated *and* not lapsed.
2. **Amendments double-counted**: amendments and continuations are separate rows in state data; they belong to the original lien, not on top of it.
3. **Wrong-company matches**: short and common names ("M & C Concrete", "Star Group") easily match another company. Look for a match score, the matched legal name, and similar names kept apart.
4. **Charged for failed rows**: check whether you pay when a state source fails or nothing is found. Every input should get a row that says found, not found or failed.

**Who it's for**

- **KYB, onboarding and compliance teams** checking that a customer, vendor or borrower is a registered entity in good standing.
- **Lenders, fintechs and payment companies** screening small-business applicants in bulk.
- **Procurement and vendor-management teams** cleaning up supplier lists.
- **Data teams and AI agents** that need to resolve a messy company name to a registered legal entity and ID.

**Why this Actor**

- **Built for batches**: 1 or 10,000 names per run, one row per input, NOT_FOUND rows included, so your output lines up with your list.
- **Fuzzy name matching**: "Joes Pizza llc", "JOE'S PIZZA, L.L.C." and "Joe's Pizza" all match. Legal-form words, punctuation, "&" vs "and" and word order are ignored, and small typos are found (flagged POSSIBLE, since a one-letter change can be a different company). Every match carries a score and a match status (EXACT, STRONG, POSSIBLE, ID_MATCH, NOT_FOUND).
- **Official state open-data APIs only**: no scraping, no logins, no proxies, no CAPTCHAs. Every result links to the exact official record.
- **Full registries, not just new filings**: entities going back to the 1800s.
- **Entity-level data only**: no names of officers, members or individual agents, and no street addresses by default.
- **Agent-ready**: every input field has a plain, machine-readable description, so it works as a tool through the Apify MCP server and API.

**Why choose this Actor**
| | |
|---|---|
| Reliability | 10 of 10 runs succeeded since launch (Oct 16, 2026); timeouts, 429 and 5xx errors retried with exponential backoff (up to 5 attempts); if every state is down you get a free SEARCH_FAILED row; any state that failed is listed in `states_failed`, and a NOT_FOUND with a failed state is free |
| Sources | 6 official state registries (CO, CT, NY, OR, PA, TX) via open-data APIs, full history |
| Output | Exactly one row per input (including NOT_FOUND), with a 0-100 match score and match status, so results line up with your list |
| Matching | Fuzzy: legal-form words, punctuation, "&"/"and", word order and small typos handled; IDs verified exactly |
| Compliance | Entity-level data only: no officer, member or individual-agent names; street line off by default |
| Audit trail | Link to the exact official record and the state's own search page on every match |
| Price | $3.00 per 1,000 matches, $1.00 per 1,000 NOT_FOUND, no start fee |
| Speed | One company, all 6 states: about 14 s end to end by API (10 s with a state hint), measured Oct 16, 2026 |

### Quick start

**Verify a list of companies in all six states:**

```json
{ "companies": ["New Belgium Brewing", "Etsy Inc", "Sheetz"] }
```

**Search only certain states for a name** (add `|` and state codes):

```json
{ "companies": ["Columbia Sportswear | OR", "Acme Robotics | CO, TX"] }
```

**Verify by state registry ID:**

```json
{ "entityIds": ["TX:0015370710", "CO:19931026399"] }
```

**Strict verification (only near-exact names, active entities):**

```json
{ "companies": ["Etsy Inc"], "minScore": 93, "activeOnly": true }
```

### What you get (one row per input)

| Field | Description |
|---|---|
| `input`, `query`, `query_normalized` | Your input line, the searched name, and the name after normalization |
| `match_status` | `EXACT` (same name), `STRONG` (same words; spacing, order or an equivalent legal form differ), `POSSIBLE` (typo, partial name, or conflicting legal forms such as LLC vs LP vs Inc/Corp vs LLP: score 90; review), `ID_MATCH`, `NOT_FOUND`, or `SEARCH_FAILED` (a state portal was down; retry) |
| `match_score` | 0-100 name similarity of the best match |
| `state`, `entity_id`, `entity_name` | Registry state, state-assigned ID / file number and registered legal name of the best match |
| `entity_type`, `entity_type_raw` | Normalized (LLC, CORPORATION, NONPROFIT, PARTNERSHIP, OTHER) and as filed |
| `status`, `status_normalized` | Status as filed (e.g. Good Standing, Delinquent, Voluntarily Dissolved) and `ACTIVE` / `ACTIVE_NOT_IN_GOOD_STANDING` / `INACTIVE` / `UNKNOWN` |
| `tx_right_to_transact`, `tx_right_to_transact_code` | Texas only: the Comptroller's franchise-tax *right to transact business* status: `ACTIVE`, `ACTIVE_ELIGIBLE_FOR_TERMINATION`, `FORFEITED`, `FRANCHISE_TAX_INVOLUNTARILY_ENDED`, `FRANCHISE_TAX_NOT_ESTABLISHED` or `FRANCHISE_TAX_ENDED`, plus the raw code (A, D, N, I, U). A Texas company can be *Active* at the Secretary of State and still have forfeited its right to transact (code N) |
| `formation_date` | Formation or registration date in that state |
| `domestic`, `jurisdiction_of_formation` | Formed in that state, or a foreign registration, and where it was formed |
| `principal_city`, `principal_state`, `principal_zip` | Principal office location (street line only with *Include street line*) |
| `registered_agent_organization` | Commercial registered agent (CO, OR); individual agents are never returned |
| `source_record_url` | Official open-data API URL for this exact record (audit trail) |
| `official_search_url` | The state's own business search page for manual confirmation |
| `other_matches` | More candidates: the same company's registrations in other states, or similar names. For NOT_FOUND rows, the closest names |
| `states_searched`, `states_failed`, `checked_at` | What was searched and when |

The best match is the highest score; ties go to active entities, then the oldest registration (usually the company's original one). All other registrations at or above the threshold are listed in `other_matches`.

#### Example

```json
{
  "input": "New Belgium Brewing",
  "match_status": "EXACT",
  "match_score": 100,
  "state": "CO",
  "entity_id": "19931026399",
  "entity_name": "NEW BELGIUM BREWING COMPANY, INC.",
  "entity_type": "CORPORATION",
  "status": "Good Standing",
  "status_normalized": "ACTIVE",
  "formation_date": "1993-03-11",
  "domestic": true,
  "source_record_url": "https://data.colorado.gov/resource/4ykn-tg5h.json?entityid=19931026399",
  "other_matches": [{ "state": "OR", "entity_name": "NEW BELGIUM BREWING COMPANY, INC.", "match_score": 100 }, "..."]
}
```

### Re-check your list on a schedule

KYB is not one-and-done: a customer or vendor can become delinquent or dissolved after onboarding.

1. Save your company list as a **task** (paste names or state IDs).
2. Add a **schedule**, e.g. monthly on the 1st.
3. Add a **webhook** on `ACTOR.RUN.SUCCEEDED`, or filter the dataset for `status_normalized` other than `ACTIVE` in your own system.

### Use it from your app (one company per call)

Call the Actor synchronously from an onboarding or underwriting flow and get the result in the response:

```bash
curl -X POST "https://api.apify.com/v2/acts/cpt_engineering~us-company-lookup-kyb/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["New Belgium Brewing | CO"]}'
```

Add the state after `|` when you know it: it is faster. The Apify MCP server exposes the same call to AI agents.

### Coverage

| State | Source | Statuses included | Freshness |
|---|---|---|---|
| Colorado | Business Entities in Colorado (CO Dept. of State, data.colorado.gov 4ykn-tg5h), ~3.1M entities | All (good standing, delinquent, dissolved, ...) | Daily |
| Connecticut | Business Registry - Business Master (Secretary of the State, data.ct.gov n7gp-d28j), ~1.3M | All (rejected filings and name reservations excluded) | Daily |
| New York | Active Corporations (NYS Dept. of State, data.ny.gov n9v6-gdp6), ~4.3M | Active only | Daily in practice |
| Oregon | Active Businesses - ALL (Oregon SOS, data.oregon.gov tckn-sxa6) | Active only (assumed business names excluded) | Weekly |
| Pennsylvania | Registered Businesses in PA (PA Dept. of State, data.pa.gov xvd7-5r2c) | Active only | Every 1-2 weeks |
| Texas | Active Franchise Taxpayers (TX Comptroller, data.texas.gov 9cir-efmm), ~3.2M | Entities on the franchise-tax roll (incl. forfeited) | Weekly; new charters appear 3-5 weeks late |

**Texas franchise tax status:** every Texas match includes `tx_right_to_transact` (Texas Comptroller franchise-tax status), so you can catch companies that forfeited their right to transact business in Texas.

**Important:** in NY, OR, PA and TX a dissolved or very new company may return `NOT_FOUND`. A NOT_FOUND result means "not in the published dataset", not proof that the company never existed. For other states, use that state's own search.

### Pricing

Pay per lookup, with no start fee:

| Result | Price per 1,000 lookups (no discount) |
|---|---|
| Match found (`EXACT`, `STRONG`, `POSSIBLE` or `ID_MATCH`) | **$3.00** |
| No match (`NOT_FOUND`) | **$1.00** |
| `NOT_FOUND` while any searched state portal failed (`states_failed` not empty) | free |
| `SEARCH_FAILED` (every searched state portal was down) | free |

Apify Store discount tiers pay less:

| Tier | Match found / 1,000 | No match / 1,000 |
|---|---|---|
| No discount (Free / starter) | $3.00 | $1.00 |
| Bronze | $2.79 | $0.93 |
| Silver | $2.61 | $0.87 |
| Gold and above | $2.40 | $0.80 |

Example: 1,000 names where 800 are found costs 800 x $0.003 + 200 x $0.001 = **$2.60**. Set *Max lookups* or a run spend limit to cap a run.

### Speed and cost tips

- State portals allow about one request per second, so a lookup takes about 1-3 seconds per state searched; states are searched in parallel. 100 names in all six states take about 3-5 minutes.
- If you know the state, add ` | ST` to the name or set *States*: it is faster.
- Set *Max lookups* to cap a run.

### Data and privacy

Entity-level data only:

- **Never returned:** names of individuals (officers, members, managers, organizers, individual registered agents, service-of-process addressees), their addresses, mailing addresses, emails and owner-demographic flags. These columns are never downloaded.
- **Texas:** sole proprietorships and partnerships of individuals are excluded; the taxpayer street address is never downloaded.
- **Oregon:** assumed business names (DBAs, often sole proprietors) are excluded.
- **Street line off by default**; turn on *Include street line* if you need it.

You are responsible for using the data lawfully. This Actor is a data tool, not a consumer report, legal advice or a certificate of good standing; for an official certificate, order one from the state.

### FAQ

**Is this a Secretary of State business search?** Yes, for these six states, using each state's official open-data publication (Texas: the Comptroller's franchise-tax roll of Secretary of State entities).

**How accurate is the matching?** In our October 2026 test of 46 names (real companies typed loosely, e.g. "Buc-ees", "Powells Books", "stanley black and decker", plus made-up names), every one of the 36 EXACT matches was the right company, 2 of 3 POSSIBLE rows were right, and all made-up names returned NOT_FOUND. EXACT and ID_MATCH are safe to auto-accept; review POSSIBLE rows.

**Can AI agents use it?** Yes, through the Apify MCP server or API. Input: a list of names. Output: one row per name.

**Need a list of newly registered businesses instead?** Use our sister Actor [US New Business Registrations](https://apify.com/cpt_engineering/us-business-registrations-open-data) (same six state sources, daily/weekly new-filings feed). For new private fundraises, see [Form D Filings Feed](https://apify.com/cpt_engineering/form-d-private-offerings-feed).

**Need a lien check too?** [UCC Lien Filings](https://apify.com/cpt_engineering/ucc-lien-filings) searches the same companies in the Colorado, Connecticut and Oregon UCC indexes and returns each financing statement with its lender, filing and lapse dates.

### Related Actors (same publisher)

- [**Company Due Diligence Check**](https://apify.com/cpt_engineering/company-due-diligence-check): one row per company with registry status, UCC liens (secured lenders, lapse dates), an OFAC sanctions screen and a SAM.gov federal exclusions screen, plus risk flags.
- [**UCC Lien Filings**](https://apify.com/cpt_engineering/ucc-lien-filings): new UCC-1 filings, liens lapsing soon and lien checks by company name (CO, CT, OR).

### Limitations

- Six states for now. Florida, Delaware, California and others are not included because they do not publish an open registry API.
- Data is as published by each state, with no enrichment (no phones or emails).
- Not affiliated with, endorsed by, or sponsored by any state government.

### Support

Open an issue on this Actor or email **cpt-datatools@mail.grokbot.com**. We reply to issues and support emails within 1 business day.

### Changelog

- **Oct 17, 2026 (12:30 PM):** *Tested accuracy* speed updated from the 12:11 PM ET re-test on the live build.
- **Oct 17, 2026 (afternoon):** a registered name with the same words but a conflicting legal form ("Etsy LP" for "Etsy Inc") is now `POSSIBLE` (score 90) instead of `STRONG`, so it is never presented as the same company. Equivalent forms (Inc / Corp / Co; LLC / L.L.C.) still match.
- **Oct 17, 2026 (midday):** added the *Tested accuracy* results (20-company test on the live build) and a buyer's checklist.
- **Oct 17, 2026 (later):** Colorado `entity_name` no longer carries the status suffix the registry appends to some names ("ACME LLC, Delinquent November 1, 2010" is returned as "ACME LLC"; the status stays in `status`).
- **Oct 17, 2026:** better matching for short names such as "M & C Concrete LLC" (registered name with a trailing period, extra 'starts with' search); a more generic registered name ("Acme" for "Acme Roofing Supply") is no longer offered as a match.
- **Oct 16, 2026 (late night):** new field `tx_right_to_transact` (Texas franchise-tax right to transact business).
- **Oct 16, 2026 (night):** `NOT_FOUND` is now free when any searched state portal failed (the answer may be incomplete; the state is listed in `states_failed`); daily automated self-test with source schema-change detection; *Last verified* line; support response promise.
- **Oct 16, 2026 (midday):** price set to $3.00 per 1,000 matches and $1.00 per 1,000 NOT_FOUND (tiers $2.79 / $2.61 / $2.40 and $0.93 / $0.87 / $0.80).
- **Oct 16, 2026:** launched: 6 state registries, fuzzy matching, one row per input; schedule and API guides; link to UCC Lien Filings.

### Source data disclaimer

The data made available here has been modified for use from its original source, which is the State of Colorado. THE STATE OF COLORADO MAKES NO REPRESENTATIONS OR WARRANTY AS TO THE COMPLETENESS, ACCURACY, TIMELINESS, OR CONTENT OF ANY DATA MADE AVAILABLE THROUGH THIS SITE. THE STATE OF COLORADO EXPRESSLY DISCLAIMS ALL WARRANTIES, WHETHER EXPRESS OR IMPLIED, INCLUDING ANY IMPLIED WARRANTIES OF MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. The data is subject to change as modifications and updates are complete. It is understood that the information contained in the Web feed is being used at one's own risk.

New York, Oregon, Connecticut, Pennsylvania and Texas data are provided by those states "as is", without warranty of accuracy, completeness or timeliness. Pennsylvania data: Commonwealth of Pennsylvania, Department of State, via data.pa.gov. Texas data: Texas Comptroller of Public Accounts, via the Texas Open Data Portal.

# Actor input Schema

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

Company names to verify, one per line (batch: up to 'Max lookups' per run). Legal-form words (LLC, Inc., Corp., L.P.), punctuation, '&' vs 'and' and word order are ignored when matching, and small typos are tolerated. To search specific states for one name only, add ' | ' and two-letter codes, e.g. 'Acme Robotics | CO' or 'Acme Robotics | CO, TX'. Without a suffix the name is searched in every state selected under 'States'. Each name returns exactly one result row, including NOT_FOUND rows.

## `entityIds` (type: `array`):

State-assigned registry IDs to verify, one per line, as 'STATE:ID', e.g. 'TX:0015370710' (Texas SOS file number), 'CO:19931026399', 'NY:3368051', 'OR:6599310', 'CT:0123456', 'PA:0000326968'. An ID without a state prefix is tried in every selected state. Leading zeros are optional.

## `states` (type: `array`):

Two-letter codes of the state registries to search when a name has no ' | STATE' suffix. Supported: CO, CT, NY, OR, PA, TX. Empty = all six. Searching fewer states is faster. NY, OR, PA and TX publish active entities only, so a dissolved company there returns NOT_FOUND.

## `minScore` (type: `integer`):

0-100 name similarity needed to count as a match, computed after removing legal-form words and punctuation. 100 = same name (EXACT); 93-99 = STRONG (same words but different spacing, word order or legal form, e.g. Inc vs LP); 85-92 = POSSIBLE (spelling differences or typos, or one name is the other plus extra words). Spelling differences are never better than POSSIBLE, because a one-letter change can be a different company. Below this the row is NOT_FOUND and the closest names are listed in other_matches. Raise to 93 for strict verification (EXACT/STRONG only), lower to 75 for messy lists.

## `maxOtherMatches` (type: `integer`):

How many additional candidates to list in other_matches (e.g. foreign registrations of the same company in other states, or similarly named entities). 0 = best match only.

## `activeOnly` (type: `boolean`):

Ignore entities whose status is dissolved, withdrawn, revoked, merged, forfeited etc. (status_normalized = INACTIVE). Off by default so a KYB check can see that a company exists but is dissolved (Colorado and Connecticut publish all statuses).

## `maxLookups` (type: `integer`):

Safety cap on the number of input names plus IDs processed in one run; extra inputs are skipped and counted in RUN_SUMMARY. Each lookup takes roughly 1-3 seconds per state searched because state portals allow one request per second.

## `includeStreetAddress` (type: `boolean`):

Also return the principal office street line as filed (CO, CT, OR, PA, and NY when a location is filed). Off by default: you get city/state/ZIP only, because small businesses often file a home address. Texas never returns a street line.

## `socrataAppToken` (type: `string`):

Optional free app token from the state open-data portals (Socrata/Tyler Data & Insights). Not needed; it only reduces the chance of throttling on very large batches.

## Actor input object example

```json
{
  "companies": [
    "New Belgium Brewing",
    "Etsy Inc",
    "Columbia Sportswear | OR"
  ],
  "states": [
    "CO",
    "CT",
    "NY",
    "OR",
    "PA",
    "TX"
  ],
  "minScore": 85,
  "maxOtherMatches": 5,
  "activeOnly": false,
  "maxLookups": 1000,
  "includeStreetAddress": false
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset items: one result per input (match_status, match_score, best registry match with state, entity_id, entity_name, entity_type, status, formation_date, source_record_url, other_matches). See the dataset schema for all fields.

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

JSON record RUN_SUMMARY: lookups, matches by match_status, invalid inputs, states that failed, HTTP requests and duration.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "companies": [
        "New Belgium Brewing",
        "Etsy Inc",
        "Columbia Sportswear | OR"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("cpt_engineering/us-company-lookup-kyb").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "companies": [
        "New Belgium Brewing",
        "Etsy Inc",
        "Columbia Sportswear | OR",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("cpt_engineering/us-company-lookup-kyb").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "companies": [
    "New Belgium Brewing",
    "Etsy Inc",
    "Columbia Sportswear | OR"
  ]
}' |
apify call cpt_engineering/us-company-lookup-kyb --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cpt_engineering/us-company-lookup-kyb"
        }
    }
}
```

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/UFbEtFfZKUkgg7M1L/builds/jhI78hEGzBOLSG7zs/openapi.json