# US Business Entity Search & New Business Filings (`enisbodlli/us-business-registry-search`) Actor

Search official US state business registries by company name, or pull newly registered companies by date, from the states' own open-data APIs (NY, CO, CT, OR, PA, TX). Company records only: no officer, owner or agent-person names. Every row names its source dataset. Pay per record found.

- **URL**: https://apify.com/enisbodlli/us-business-registry-search.md
- **Developed by:** [Enis Bodlli](https://apify.com/enisbodlli) (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.00 / 1,000 company records

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 Business Entity Search & New Business Filings

Run a **US business entity search** by company name, or pull the **new business filings** of the last days, straight from the open-data APIs that six states publish themselves: New York, Colorado, Connecticut, Oregon, Pennsylvania and Texas. It is built for compliance, KYB, credit and sales teams that need company records they can show to a reviewer: every row is company-level data from an official source, with no officer, owner or agent-person names in it. To try it, keep the sample input and press **Start**: 25 companies registered in New York and Colorado in the last 7 days, in a few seconds.

- **Official sources only.** Each row comes from a state's own open-data portal and says which dataset it came from, links back to the record, and carries the time the state last updated that dataset.
- **Company data, no people.** Name, register ID, entity type, status, formation date, jurisdiction, addresses and industry code. Officers, owners and agents who are people are never returned, and sole proprietors are skipped. You can check this in the dataset schema.
- **Pay only for records found.** $3.00 per 1,000 records ($2.00 on the Gold plan). A name that a register does not hold costs nothing and still gets an answer row.

### What a record looks like

```json
{
    "state": "NY",
    "entityId": "8039659",
    "name": "NEW FITNESS BOXING CONCEPT LLC",
    "entityType": "DOMESTIC LIMITED LIABILITY COMPANY",
    "status": "active",
    "statusRaw": null,
    "formationDate": "2026-10-06",
    "jurisdiction": "NY",
    "principalAddress": null,
    "mailingAddress": { "street": "418 BROADWAY, STE N", "city": "ALBANY", "state": "NY", "zip": "12207" },
    "county": "Albany",
    "registeredAgentName": "NORTHWEST REGISTERED AGENT LLC",
    "naicsCode": null,
    "sourceDataset": "Active Corporations: Beginning 1800 (New York State Department of State, data.ny.gov/n9v6-gdp6)",
    "sourceUrl": "https://data.ny.gov/resource/n9v6-gdp6.json?dos_id=8039659",
    "sourceUpdatedAt": "2026-10-07T11:26:00.000Z",
    "query": null,
    "scrapedAt": "2026-10-07T19:09:45.827Z",
    "found": true
}
```

### How to search US business entities and new filings

1. Choose the **states**.
2. Either enter **company names** (one per line, each is searched in every chosen state), or set **Registered within the last days** to get a feed of new registrations. With neither, the run lists the register newest first; companies the register gives no date for come last.
3. Narrow it if you like: entity type, status, city, ZIP code.
4. Set **Maximum records**. You pay per record, so this is the cap on the cost of the run.
5. Run it. Results are in the dataset; download them as JSON, CSV or Excel, or read them through the Apify API.

**A daily feed of new companies.** Save the input as a task, switch on **Only records not returned before** and add a schedule. Each run then returns only the registrations that earlier runs of the task have not returned, so each one is delivered and charged once.

**Name match.** "Contains" finds the text anywhere in the registered name and puts the exact name first. "Exact name" compares the whole name, punctuation included ("Tesla, Inc." is not "Tesla Inc"). "Starts with" is the middle way and the safest choice for a lookup.

**From an AI agent.** The Actor can be used as a tool through Apify's MCP server (`https://mcp.apify.com`): the agent finds it by its name, `enisbodlli/us-business-registry-search`, and calls it with an input like the ones below. The input and dataset schemas describe every field, so the agent needs no further instructions. A run answers "is this company registered in these states" in a few seconds, and the row's `sourceUrl` lets the agent cite the state's own record.

#### The six states

| State | Source dataset | Published by | Refreshed | Status | Agent | County | NAICS |
|---|---|---|---|---|---|---|---|
| NY | Active Corporations: Beginning 1800 (`data.ny.gov`, `n9v6-gdp6`) | Department of State | daily in practice | active entities only | organisations only | yes | no |
| CO | Business Entities in Colorado (`data.colorado.gov`, `4ykn-tg5h`) | Department of State | daily | yes | organisations only | no | no |
| CT | Connecticut Business Registry, Business Master (`data.ct.gov`, `n7gp-d28j`) | Secretary of the State | daily | yes, with sub-status | no | no | yes |
| OR | Active Businesses - ALL (`data.oregon.gov`, `tckn-sxa6`) | Secretary of State, Corporation Division | weekly | active entities only | organisations only | no | no |
| PA | Registered Businesses in PA (`data.pa.gov`, `xvd7-5r2c`) | Department of State | monthly as stated | active registrations only | no | yes | no |
| TX | Active Franchise Taxpayers (`data.texas.gov`, `9cir-efmm`) | Comptroller of Public Accounts | every few days | yes (right to transact business) | no | no | yes |

Checked on 2026-10-07. `sourceUpdatedAt` on each row shows how fresh the state's file was when the row was read.

### Pricing

Pay per event. You pay for results, not for compute time or storage.

| Event | Free and Bronze | Silver | Gold |
|---|---|---|---|
| `company-record`: one company record found and stored | $3.00 per 1,000 | $2.50 per 1,000 | $2.00 per 1,000 |
| Actor start | $0.00005 per run | $0.00005 per run | $0.00005 per run |

Not charged: a name that a register does not hold (the row with `found: false`), sole proprietors that are skipped, records an earlier run already returned, and searches that fail.

**Worked example.** A task that pulls the last 7 days of new registrations in New York and Colorado every morning with Maximum records at 500 costs 500 x $0.003 + $0.00005 = $1.50 a run on the Free or Bronze plan, $1.25 on Silver and $1.00 on Gold. A single lookup of one company name in all six states that finds one record costs $0.003 + $0.00005 = $0.00305. The same lookup that finds nothing costs $0.00005.

The maximum charge you set for a run is respected: the Actor stops before the next record would pass it and says so in the status message. If a run fails or is aborted you pay only for the records that are already in the dataset. A run that is restarted or resurrected reads its own dataset first, so it never stores or charges the same record twice.

### Input example

New registrations of LLCs and corporations in two states, delivered once each:

```json
{
    "states": ["NY", "CO"],
    "registeredWithinDays": 7,
    "entityTypes": ["llc", "corporation"],
    "maxResults": 500,
    "onlyNew": true
}
```

Look up three names in all six states, at most five matches per state and name:

```json
{
    "states": ["NY", "CO", "CT", "OR", "PA", "TX"],
    "nameQueries": ["Blue Bottle Coffee", "Northwind Traders", "Acme Holdings"],
    "matchMode": "startsWith",
    "status": "active",
    "maxResultsPerState": 5,
    "maxResults": 100
}
```

### Output example

```json
[
    {
        "state": "CO",
        "entityId": "20268245921",
        "name": "Commoban Inc",
        "entityType": "Domestic profit corporation",
        "status": "active",
        "statusRaw": "Good Standing",
        "formationDate": "2026-10-06",
        "jurisdiction": "CO",
        "principalAddress": { "street": "1500 N GRANT ST STE R", "city": "DENVER", "state": "CO", "zip": "80203" },
        "mailingAddress": null,
        "county": null,
        "registeredAgentName": "Registered Agents Inc",
        "naicsCode": null,
        "sourceDataset": "Business Entities in Colorado (Colorado Department of State, data.colorado.gov/4ykn-tg5h)",
        "sourceUrl": "https://data.colorado.gov/resource/4ykn-tg5h.json?entityid=20268245921",
        "sourceUpdatedAt": "2026-10-07T11:19:36.000Z",
        "query": null,
        "scrapedAt": "2026-10-07T19:09:45.827Z",
        "found": true
    },
    {
        "state": "TX",
        "entityId": "32108279921",
        "name": "ALFIE LABS INC.",
        "entityType": "FOREIGN PROFIT CORPORATION",
        "status": "active",
        "statusRaw": "Active",
        "formationDate": "2026-12-13",
        "jurisdiction": null,
        "principalAddress": null,
        "mailingAddress": { "street": "10601 CLARENCE DR STE 250", "city": "FRISCO", "state": "TX", "zip": "75033" },
        "county": null,
        "registeredAgentName": null,
        "naicsCode": null,
        "sourceDataset": "Active Franchise Taxpayers (Texas Comptroller of Public Accounts, data.texas.gov/9cir-efmm)",
        "sourceUrl": "https://data.texas.gov/resource/9cir-efmm.json?taxpayer_number=32108279921",
        "sourceUpdatedAt": "2026-10-03T08:40:57.000Z",
        "query": "Alfie Labs",
        "scrapedAt": "2026-10-07T19:09:46.102Z",
        "found": true
    },
    {
        "state": "OR",
        "entityId": null,
        "name": null,
        "entityType": null,
        "status": null,
        "statusRaw": null,
        "formationDate": null,
        "jurisdiction": null,
        "principalAddress": null,
        "mailingAddress": null,
        "county": null,
        "registeredAgentName": null,
        "naicsCode": null,
        "sourceDataset": "Active Businesses - ALL (Oregon Secretary of State, Corporation Division, data.oregon.gov/tckn-sxa6)",
        "sourceUrl": "https://data.oregon.gov/resource/tckn-sxa6.json",
        "sourceUpdatedAt": "2026-09-29T13:35:00.000Z",
        "query": "Alfie Labs",
        "scrapedAt": "2026-10-07T19:09:46.455Z",
        "found": false
    }
]
```

`state` and `entityId` together are unique within a run. Every field is always present; `null` means the register did not say. `status` is one of `active`, `inactive` and `unknown`; `statusRaw` keeps the register's own words. A formation date in the future is a filing with a delayed effective date. Rows from several states arrive in the order the portals answer, so sort by `state` if you need them grouped.

The run also writes a `RUN_SUMMARY` record to its key-value store: totals, what was skipped and why, and the outcome of every search.

### Limits

**Company-level data only.** The dataset never holds the name, home address or ID of a natural person.

- Officers, directors, principals and owners are not returned. The Actor does not even request the columns that hold them.
- A registered agent is returned only when it is an organisation. An agent who is a person is left out.
- Sole proprietors, estates, partnerships of individuals and assumed business names with no organisation behind them are skipped and counted (`soleTradersSkipped` in the summary). In Oregon about four in five assumed business names are skipped for this reason.
- In New York the mailing address is the address for service of process. It is returned only when the name on it is the company itself or another organisation.
- Address lines are returned as the register writes them, with three exceptions that keep names of people out: a "c/o" or "attn" line, a first line with no number and no street word, and a line below the street that reads like a full name are dropped unless they name an organisation. A town repeated on a second line goes with the last rule; it is in `city`. A name that a filer wrote into the street line itself cannot be told apart.

**What is not covered.**

- Other states. Only states that publish their register through an official open-data API are read: the six above. The other registries, South Carolina among them, are websites that need a browser, a proxy or a CAPTCHA to read, and this Actor does not do that. Iowa and Hawaii no longer offer such an API (checked 2026-10-07).
- Detail pages and filing history: they are not in the open-data sets.
- UCC liens: a different source in each state, not included.
- Phone numbers, email addresses, contact checks and lead scores: not returned.
- A separate standing field: the datasets publish one status value, and `statusRaw` returns it unaltered.
- Lookup by entity number: not in this version. Search by name.
- A proxy setting or an API token input: there is none, because none is needed. The portals are read with plain requests, one per second each. A portal that throttles is asked again after a pause, and if it keeps refusing the run reports it; nothing is done to get around a refusal.
- Real-time register state: rows are as fresh as the state's published file. `sourceUpdatedAt` shows its age.
- City business-licence datasets: not included.

**Per state.**

- New York, Oregon and Pennsylvania publish active entities only. `status` is always `active` there and `"status": "inactive"` returns nothing from them.
- Texas rows come from the Comptroller's roll of franchise taxpayers, not from the Secretary of State's register. They have no agent, the address is the taxpayer's mailing address, the status is the Comptroller's "right to transact business", and the county is published only as a number, which the Actor does not return.
- Colorado type codes are written out from the Secretary of State's list. Six codes that the list does not explain (`FO`, `GP`, `UNA`, `DLCA`, `CS`, `FLCA`) are returned as published and count as "Other" in the entity-type filter. About 5,400 companies formed outside Colorado are filed under `FO` whatever their legal form (counted 2026-10-08), so an LLC or corporation filter leaves them out in Colorado.
- Pennsylvania does not say where a foreign registration was formed, so `jurisdiction` is `PA` for domestic ones and null for the rest.

**Caps.**

- Up to 500 company names and up to 1,000,000 records per run.
- Several states share "Maximum records" and the maximum charge of a run: each state gets an equal part first, and what one state does not use goes to the others. A state whose portal takes more than 30 seconds for its first answer can find part of its share taken. "Maximum records per state" sets a fixed cap per state instead.
- "Only records not returned before" remembers what a task returned for 400 days, up to 200,000 records per task and state. It stops a listing after 20 pages in a row with nothing new.
- One request per second per state portal, as their `robots.txt` asks. A name lookup takes one to two seconds per state, and a listing reads up to 1,000 records per request (200 in Oregon). The states are read side by side.
- Reading a whole register is slow at that pace: a million records take at least 17 minutes per state, and all of Oregon about an hour and a half. Set the run timeout to match. A run that times out keeps what it stored, and resurrecting it goes on from the page it had reached.

**Colorado's notice.** The State of Colorado asks applications that use its data to say the following, and it applies to every Colorado row: the data has been modified for use from its original source, the State of Colorado; the State makes no representation or warranty as to its completeness, accuracy, timeliness or content; the State disclaims all warranties, express or implied, including merchantability and fitness for a particular purpose; the data is subject to change as modifications and updates are completed; and the information is used at one's own risk. The State's own wording is at `https://data.colorado.gov/terms`. The other states publish their data as is, without warranty, too.

### FAQ

**Is it legal?** The Actor reads public datasets that the states publish for reuse through a documented API, without logging in, and it returns company-level fields only. New York, Colorado and Connecticut state their terms on their portals; Colorado and Connecticut place the data in the public domain. You are responsible for how you use the data and for following the laws that apply to you. A company name can contain a person's name ("Jane Doe Consulting LLC"); that is the company's registered name and is returned as such.

**A name lookup found nothing.** You get a row with `found: false` for each state that does not hold the name, free of charge. Check the match mode first: "Exact name" needs the punctuation of the register. Then check the state: only the six above are read, and New York, Oregon and Pennsylvania list active entities only.

**My scheduled run returned an empty dataset.** With "Only records not returned before" that means nothing new was registered since the last run, or the state has not refreshed its file yet. Compare `perState.<state>.sourceUpdatedAt` in `RUN_SUMMARY` with the day before.

**`mailingAddress` is null on many New York rows.** Those companies named a person on the service-of-process line, and the Actor does not return a person's address.

**A search failed.** `RUN_SUMMARY` lists every search with its result and reason. "refused": the portal answered 401, 403 or 404, sent a challenge page, or throttled three searches in a row. "unavailable": it did not answer after five attempts (two when it timed out), or kept answering "too many requests". "changed": the state renamed a column of its dataset or sent something that is not the data; please open an issue on the Issues tab and it will be fixed. A portal that leaves three searches in a row without an answer gets no more requests in that run, and its remaining searches are marked the same way without being sent. Searches that worked are in the dataset either way. Resurrecting the run tries the "unavailable" searches again and charges only the records it adds; a new run of the same input returns and charges every record again.

**Can a rerun charge me twice?** Not within one run: a restarted or resurrected run skips every record that is already in its dataset. Two separate runs of the same search return the same records twice unless "Only records not returned before" is on.

### More Actors from this developer

- [North Data Scraper: German & European Companies](https://apify.com/enisbodlli/northdata-company-scraper)
- [Handelsregister Scraper: German Company Register](https://apify.com/enisbodlli/handelsregister-scraper)
- [European Company Registry Search](https://apify.com/enisbodlli/eu-company-registry-search)
- [Brazil CNPJ Scraper: Company Search & Lookup](https://apify.com/enisbodlli/brazil-cnpj-company-search)
- [Company Jobs Search](https://apify.com/enisbodlli/company-jobs-search)
- [ATS Job Postings: Workday, Greenhouse, Lever & Ashby](https://apify.com/enisbodlli/ats-job-postings)
- [Workday Jobs Scraper](https://apify.com/enisbodlli/workday-jobs-scraper)
- [Greenhouse Jobs Scraper](https://apify.com/enisbodlli/greenhouse-jobs-scraper)
- [Lever Jobs Scraper](https://apify.com/enisbodlli/lever-jobs-scraper)
- [Ashby Jobs Scraper](https://apify.com/enisbodlli/ashby-jobs-scraper)
- [Website Contact Scraper](https://apify.com/enisbodlli/website-contact-scraper)
- [Email Validator](https://apify.com/enisbodlli/email-validator)

# Changelog

This Actor's version history is a separate document: https://apify.com/enisbodlli/us-business-registry-search/changelog.md

# Actor input Schema

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

The state registers to read. These six publish their business register through an official open-data API: New York, Colorado, Connecticut, Oregon, Pennsylvania and Texas (Texas: the Comptroller's roll of franchise taxpayers). Other states are not covered.

## `nameQueries` (type: `array`):

Company names to look up, one per line. Each name is searched in every chosen state, in the company-name column only. Upper and lower case do not matter. Leave empty to list companies by registration date instead. Up to 500 names per run, 2 to 200 characters each.

## `nameQuery` (type: `string`):

One company name, for callers that send a single name. It is searched together with the names in "Company names".

## `matchMode` (type: `string`):

How a company name is compared with the register. "contains": the register's name holds the text anywhere; the exact name comes first, then names that begin with it. "exact": the whole name is equal, punctuation included, so "Tesla, Inc." does not match "Tesla Inc". "startsWith": the register's name begins with the text.

## `registeredWithinDays` (type: `integer`):

Only companies registered or formed in the last N days, counted back from today (UTC). Use this for a scheduled feed of new business filings. Do not combine it with the two date fields below.

## `registeredAfter` (type: `string`):

Only companies registered or formed on or after this date, written as YYYY-MM-DD.

## `registeredBefore` (type: `string`):

Only companies registered or formed on or before this date, written as YYYY-MM-DD.

## `entityTypes` (type: `array`):

Only these kinds of entity. Each register's own wording is sorted into five groups: limited liability companies, corporations, nonprofit corporations, partnerships (LP, LLP, LLLP, general) and everything else (trusts, cooperatives, associations, assumed names and so on). Leave empty for all.

## `status` (type: `string`):

"active": only entities the register shows as existing and entitled to do business. "inactive": only dissolved, withdrawn, revoked, merged, delinquent or forfeited entities. Colorado, Connecticut and Texas publish a status. New York, Oregon and Pennsylvania publish active entities only, so "inactive" returns nothing from them.

## `city` (type: `string`):

Only companies whose address is in this city, compared with the whole city name without regard to case. The address is the principal one where the register has it (Colorado, Connecticut, Oregon, Pennsylvania), the mailing address in Texas, and the location or service-of-process address in New York.

## `zip` (type: `string`):

Only companies whose ZIP code begins with these digits: a full 5-digit ZIP or the first 3 or 4 digits of an area. The same address is used as for "City".

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

The run stops after this many company records. You pay per record, so this is also the cap on the cost of the run. Several states share it: each gets an equal part first, and what one state does not use goes to the others. Use "Maximum records per state" for a fixed cap per state.

## `maxResultsPerState` (type: `integer`):

At most this many records from each state, and for each company name when names are searched. 0 means no cap per state.

## `onlyNew` (type: `boolean`):

Return only companies that an earlier run of the same saved task has not returned. Use it with a schedule to get each new registration once. The memory is kept per task and state for 400 days; runs started without a task share memory per identical search.

## Actor input object example

```json
{
  "states": [
    "NY",
    "CO"
  ],
  "nameQueries": [
    "Tesla",
    "Blue Bottle Coffee"
  ],
  "nameQuery": "Tesla",
  "matchMode": "contains",
  "registeredWithinDays": 7,
  "registeredAfter": "2026-09-01",
  "registeredBefore": "2026-09-30",
  "entityTypes": [
    "llc",
    "corporation"
  ],
  "status": "active",
  "city": "Albany",
  "zip": "10001",
  "maxResults": 25,
  "maxResultsPerState": 10,
  "onlyNew": false
}
```

# Actor output Schema

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

One row per company record found, in the run's default dataset: state, register ID, name, entity type, status, formation date, addresses and the source dataset. A name that a state's register does not hold gets a free row with found set to false.

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

Totals for the run and the outcome of every search: records stored and charged, names not found, sole proprietors left out, searches that failed and why, and which limit stopped the run.

# 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 = {
    "states": [
        "NY",
        "CO"
    ],
    "registeredWithinDays": 7,
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("enisbodlli/us-business-registry-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 = {
    "states": [
        "NY",
        "CO",
    ],
    "registeredWithinDays": 7,
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("enisbodlli/us-business-registry-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 '{
  "states": [
    "NY",
    "CO"
  ],
  "registeredWithinDays": 7,
  "maxResults": 25
}' |
apify call enisbodlli/us-business-registry-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,enisbodlli/us-business-registry-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/APj1ANj0gpYOI48DQ/builds/y0KSZiJvYHQeMB1J9/openapi.json
