# New Jersey Business Registry Lookup & Name Checker (`vexaloom-labs/new-jersey-business-registry-lookup-and-name`) Actor

Look up New Jersey registered businesses by name, keyword or entity ID, and check whether a candidate business name is available for a new filing. Returns entity ID, entity type, city and incorporation date.

- **URL**: https://apify.com/vexaloom-labs/new-jersey-business-registry-lookup-and-name.md
- **Developed by:** [vexaloom-labs](https://apify.com/vexaloom-labs) (community)
- **Categories:** Automation, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## New Jersey Business Registry Lookup & Name Checker

Look up New Jersey registered businesses in the state's free public registry, clear a candidate name before filing, or trace a company through its principal, registered agent or previous name. The actor also lists the free document index for any entity, including the document names, filing years and whether certified or non-certified copies can be ordered. No login, account, API key or proxy setup is required.

### What this actor does

- **Six modes:** `byName`, `byKeyword`, `byEntityId`, `byLinkedName`, `availability`, and `documents`
- **Batch lookups:** up to 50 names, 20 keyword phrases or 200 entity IDs per run
- **Reverse searches:** find entities by principal/officer name, registered-agent name or associated/previous name, with 17 entity-type codes and an exact city filter
- **Name availability:** see whether a candidate name is free, plus the source's list of similar registered names
- **Free document index:** list every orderable charter document with its filing year and copy options
- **Provenance:** every business record says which mode and search term produced it
- Fields the source does not publish for a record are omitted rather than sent empty

### Services

| Service | What you get | Cost |
|---|---|---|
| New Jersey Business Name Search | Name, keyword, entity ID and name-availability results | Free, no login |
| Business Records Service (BRS) | Reverse search by principal, registered agent or associated name; 10 results per page | Free, no login |
| BRS document index | Document names, filing years, certified/non-certified copy availability | Free, no login |
| Status reports, standing certificates, document copies, bulk lists | Not accessed by this actor | Paid state products |

### How it works

The actor queries the New Jersey Division of Revenue and Enterprise Services' own public search pages, reads the result tables, and returns them as clean JSON records. Name and keyword searches are single-page queries; reverse searches walk the source's 10-row pages until your `maxItems` is reached or the source runs out. Each business is deduplicated by its 10-digit entity ID, so batch queries never repeat a company.

The state site answers US addresses only, so the actor selects a working US connection automatically. You do not configure a proxy or supply credentials.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byName` | `byName` / `byKeyword` / `byEntityId` / `byLinkedName` / `availability` / `documents` |
| `businessNames` | array | `["Amazon"]` | Names to search (mode=`byName`) or candidate names to check (mode=`availability`). Up to 50. |
| `keywordSearches` | array | – | Keyword phrases (mode=`byKeyword`); every word in a phrase must appear in the name. Up to 5 words per phrase, 20 phrases. |
| `entityIds` | array | – | Exact 10-digit entity IDs (mode=`byEntityId`, `documents`). Up to 200. |
| `linkType` | string | `principal` | `principal` / `registeredAgent` / `associatedName` (mode=`byLinkedName`) |
| `linkedName` | string | – | Last name, business name, agent name, or previous/alternate name (mode=`byLinkedName`) |
| `linkedFirstName` | string | – | Optional first name for a principal search |
| `linkedMiddleName` | string | – | Optional middle name for a principal search |
| `linkedCity` | string | – | Optional city for a principal or registered-agent search |
| `entityTypes` | array | – | Keep only these 17 codes: `NP`, `FR`, `DB`, `LF`, `DP`, `LP`, `NF`, `PA`, `LLC`, `FLC`, `LLP`, `FLP`, `GP`, `FGP`, `AUT`, `NJR`, `BDP` |
| `cityFilter` | string | – | Exact, case-insensitive on-file city match |
| `maxItems` | integer | `100` | Hard cap on emitted records, 1–500 |

#### Example: batch name search with filters

```json
{
  "mode": "byName",
  "businessNames": ["Amazon", "Prudential", "PURE"],
  "entityTypes": ["LLC", "DP"],
  "cityFilter": "NEWARK",
  "maxItems": 100
}
```

#### Example: check a name before filing

```json
{
  "mode": "availability",
  "businessNames": ["My Brand New Startup Idea"]
}
```

#### Example: find entities by registered agent

```json
{
  "mode": "byLinkedName",
  "linkType": "registeredAgent",
  "linkedName": "CT CORPORATION SYSTEM",
  "maxItems": 50
}
```

#### Example: list a document index

```json
{
  "mode": "documents",
  "entityIds": ["5106301000", "0450567823"]
}
```

#### Example: keyword phrase search

```json
{
  "mode": "byKeyword",
  "keywordSearches": ["Pizza NJ", "Garden Landscaping"],
  "maxItems": 50
}
```

### Output

#### Registered-business records (`byName`, `byKeyword`, `byEntityId`, `byLinkedName`)

- `businessName` — name as filed with the state
- `entityId` — 10-digit New Jersey entity ID
- `city` — on-file city, when published
- `entityTypeAbbr` — short type code such as `LLC`, `DP` or `FLC`
- `entityTypeFull` — full type description; omitted for the rare `NV` rows that have none
- `incorporatedDate` — full incorporation date (`YYYY-MM-DD`) on name/keyword/ID searches
- `incorporatedMonth` — incorporation month (`YYYY-MM`) on reverse searches, which publish month/year only
- `searchMode`, `searchTerm` — which query produced the record
- `linkType` — `principal`, `registeredAgent` or `associatedName` on reverse searches
- `sourceUrl` — the registry page that produced the record
- `recordType` — `"business"`, `scrapedAt` — ISO 8601 lookup time

#### Availability records (`availability`)

- `queriedName` — the candidate name that was checked
- `isAvailable` — `true` or `false`
- `message` — the registry's explanation as plain text
- `similarBusinesses` — up to 50 similar registered names when the name is unavailable
- `sourceUrl`, `recordType: "availability"`, `scrapedAt`

Validation responses (name too short or containing a designator) produce no record and are reported in the run status.

#### Document-index records (`documents`)

- `entityId`, `businessName`
- `documents[]` — `documentName`, `filingYear`, `certifiedAvailable`, `nonCertifiedAvailable`
- `documentCount` — number of documents found; `0` is a real value
- `searchMode: "documents"`, `searchTerm`, `sourceUrl`, `recordType: "documentIndex"`, `scrapedAt`

### Use cases

- **New-business filing prep** — clear a candidate name and see conflicting registrations before filing
- **Vendor and counterparty checks** — confirm legal name, entity type, city and incorporation date
- **Lead list building** — collect New Jersey businesses by name prefix, keyword or entity type
- **Registry enrichment** — append state entity details to an existing company dataset by entity ID
- **Compliance and legal research** — trace a company through a principal, registered agent or previous name, and inspect its charter-document history
- **Name-change and merger research** — find entities that used an earlier or alternate name

### Usage cost

Runs are billed in Apify platform compute units for the time the actor is running. The default prefill performs one search and returns one record, so a scheduled run costs a fraction of a cent. Larger batch or reverse-lookup runs take longer because the source serves 10 rows per page. The US connection is included in the platform's proxy allowance; the actor does not purchase paid state reports, certificates or document copies.

### FAQ

**Is this an official New Jersey state tool?**
No. It is an independent, third-party actor that reads the state's free public search pages. It is not affiliated with or endorsed by the State of New Jersey.

**Does a name search find the word anywhere in the name?**
No. New Jersey's name search is a prefix match: `Amazon` finds names that begin with Amazon, and a leading `The` is ignored. `mazon` will not find Amazon. Keyword search is different — every keyword word can appear anywhere in the name, in any order.

**Why do I get exactly 500 rows for a broad query?**
The state's public search displays at most 500 rows per query. That is the source's limit, not a cap added by this actor. Use a longer name prefix, more specific keywords, or a list of entity IDs to reach other records.

**What is the difference between a reverse search and an officer/agent field?**
The free BRS search can find businesses by a principal or registered-agent name, but it does not publish the officer or agent values for a company. Those values are inside the state's paid status report, which this actor never requests.

**Can I download the actual documents?**
No. The free document index lists document names, filing years and whether certified/non-certified copies are orderable. The copies themselves are paid state products.

**Why is there no active/inactive status?**
The free search does not include an operating-status or standing column. Status reports are a separate paid product.

**Why does an availability check reject a name that looks fine?**
The availability tool requires at least four effective characters after ignoring articles, conjunctions, spaces and punctuation, and it rejects names that already contain a designator such as LLC or Inc. Both cases are reported in the run status, not as a false "not available" result.

**Do I need to set up a proxy?**
No. The actor chooses a working US connection automatically. Just fill in the input and run it.

**How fresh is the data?**
The state says electronic filings are reflected within about two business days. County-level DBAs and trade names are separate registries and are not part of this dataset.

### Notes

- The 10-digit entity ID is the natural key; duplicate rows in a batch are collapsed to one record.
- Name and keyword searches return full dates; BRS reverse searches publish month and year only.
- Cities are published for about two-thirds of entities; missing cities are omitted, not empty strings.
- The rare `NV` entity type has no full description and is returned with the code alone.
- Invalid entity IDs and source validation messages are listed in the run status instead of being silently dropped.

### Limitations

- **500-row display limit** on every free search surface; broad prefixes cannot be exhausted in one query.
- **No status, standing, officers, directors, registered-agent values or street address** — these live in paid state reports.
- **No document downloads** — only the free index is available.
- **No bulk entity list** by filing date or type — the state sells that list.
- **No county-clerk DBAs** — they are not part of the state registry.
- **No trade-name/trade-mark search** in this version.
- **Reverse searches return month/year only**, not a full incorporation date.
- **Result ordering follows the source** and can shift between runs for common names.

# Actor input Schema

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

What to fetch.

## `businessNames` (type: `array`):

One or more names (mode=byName, availability). Name search is a prefix match: 'Amazon' finds names starting with Amazon, and a leading 'The' is ignored. Availability checks need a base name without a designator (no LLC, Inc., Corp., etc.) and at least 4 effective characters. Up to 50 names.

## `keywordSearches` (type: `array`):

One or more keyword phrases (mode=byKeyword). Each phrase is split into words, and every word must appear in the business name; up to 5 words per phrase and 20 phrases.

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

Exact 10-digit New Jersey entity IDs (mode=byEntityId, documents). Invalid IDs are reported in the run status instead of being dropped silently. Up to 200 IDs.

## `linkType` (type: `string`):

Which free Business Records Service search to use (mode=byLinkedName).

## `linkedName` (type: `string`):

Last name, business name, registered-agent name, or previous/alternate name to search (mode=byLinkedName).

## `linkedFirstName` (type: `string`):

Optional first name when linkType=principal (mode=byLinkedName).

## `linkedMiddleName` (type: `string`):

Optional middle name when linkType=principal (mode=byLinkedName).

## `linkedCity` (type: `string`):

Optional city filter for principal or registered-agent searches (mode=byLinkedName).

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

Keep only these New Jersey entity types. Empty means no filter. Filters run on every page, not only after the 500-row display cap.

## `cityFilter` (type: `string`):

Keep only businesses whose on-file city matches exactly (case-insensitive). Leave blank for all cities.

## `maxItems` (type: `integer`):

Hard cap on emitted records (1-500, the source's display limit). Applied exactly, including when it is above 200.

## Actor input object example

```json
{
  "mode": "byName",
  "businessNames": [
    "Amazon"
  ],
  "keywordSearches": [],
  "entityIds": [],
  "linkType": "principal",
  "entityTypes": [],
  "cityFilter": "",
  "maxItems": 1
}
```

# Actor output Schema

## `businesses` (type: `string`):

Dataset containing business, availability and document-index records.

# 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 = {
    "mode": "byName",
    "businessNames": [
        "Amazon"
    ],
    "keywordSearches": [],
    "entityIds": [],
    "linkType": "principal",
    "entityTypes": [],
    "cityFilter": "",
    "maxItems": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("vexaloom-labs/new-jersey-business-registry-lookup-and-name").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 = {
    "mode": "byName",
    "businessNames": ["Amazon"],
    "keywordSearches": [],
    "entityIds": [],
    "linkType": "principal",
    "entityTypes": [],
    "cityFilter": "",
    "maxItems": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("vexaloom-labs/new-jersey-business-registry-lookup-and-name").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 '{
  "mode": "byName",
  "businessNames": [
    "Amazon"
  ],
  "keywordSearches": [],
  "entityIds": [],
  "linkType": "principal",
  "entityTypes": [],
  "cityFilter": "",
  "maxItems": 1
}' |
apify call vexaloom-labs/new-jersey-business-registry-lookup-and-name --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vexaloom-labs/new-jersey-business-registry-lookup-and-name"
        }
    }
}
```

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/b9tHhO0tvAYzBlP9Y/builds/yzCQPRFfa7uWBW40K/openapi.json