# New Jersey DOR Business Name Search Scraper (`crawlerbros/new-jersey-dor-business-name-search-scraper`) Actor

Search NJ's free public Business Name Search by name, keywords, or entity ID. Also checks business-name availability for new filings. Get business name, entity ID, entity type, city, incorporation date.

- **URL**: https://apify.com/crawlerbros/new-jersey-dor-business-name-search-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (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 $3.00 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## New Jersey DOR Business Name Search Scraper

Search the **New Jersey Division of Revenue and Enterprise Services'** free public Business Name Search. Look up registered businesses by name, keywords, or exact entity ID, and check whether a candidate business name is available for a new filing. HTTP-only via the public `njportal.com/DOR/BusinessNameSearch` search — no login required.

### Data Source & Usage Notes

- **Free, public, no login.** `njportal.com/DOR/BusinessNameSearch` is New Jersey's own free business search; no account, API key, or paywall stands between a user and this data. The site uses a standard per-request anti-forgery token (cookie + hidden form field), not a CAPTCHA.
- **Scope: name-matching and availability, not full entity records.** New Jersey's free Business Name Search returns business name, entity ID, entity/filing type, city, and incorporation date. It does **not** expose officers, registered agents, or a full operating-status (active/inactive/dissolved) field on this free search — that data requires the state's paid Business Entity Status Report / Certificate of Standing products, which are out of scope for a free, no-login actor. See "What's NOT included" below.
- **Not affiliated with the State of New Jersey.** This is an independent third-party tool using the source's own public, no-login search forms.

### What this actor does

- **Four modes:**
  - `byName` — registered-business search, name contains-match
  - `byKeyword` — registered-business search, up to 5 keywords (all must appear in the name, in any order)
  - `byEntityId` — registered-business search, exact 10-digit entity ID
  - `availability` — checks whether a candidate name (without a business designator like `LLC`/`Inc`/`Corp`) conflicts with an already-registered name, and returns the conflicting/similar names on file
- **Entity/filing type on every registered-business record** — both the short code (e.g. `LLC`) and the full description (e.g. `Domestic Limited Liability Company`)
- **Client-side filters** — narrow `byName`/`byKeyword` results by entity-type substring or exact city
- **Empty fields are omitted**

### What's NOT included (and why)

- **Operating status (active/inactive/dissolved).** Confirmed against the live results table: the free registered-business search returns Business Name / Entity ID / City / Type / Incorporated Date only — there is no status column. New Jersey's official status product ("Business Entity Status Report") is a separate, paid document.
- **Officers, registered agent, or filing history.** Not exposed by any public, no-login endpoint on this site.
- **More than ~50 similar-name matches on an unavailable name.** The Availability search's own conflict list is capped at 50 by the source itself ("This list includes only first 50 matches found").

### Output per record

#### Registered-business modes (`byName`, `byKeyword`, `byEntityId`)

- `businessName` — as filed
- `entityId` — 10-digit New Jersey entity ID
- `city` — on file, when present
- `entityTypeAbbr` — short code, e.g. `LLC`, `DP`, `FLC`
- `entityTypeFull` — full description, e.g. `Domestic Limited Liability Company`
- `incorporatedDate` — `YYYY-MM-DD`
- `sourceUrl`
- `recordType: "business"`, `scrapedAt`

#### `availability` mode

- `queriedName` — the candidate name checked
- `isAvailable` — `true`/`false`
- `message` — the source's own explanation text
- `similarBusinesses` — array of conflicting/similar registered names on file (only present when `isAvailable` is `false`)
- `sourceUrl`
- `recordType: "availability"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byName` | `byName` / `byKeyword` / `byEntityId` / `availability` |
| `businessName` | string | `Amazon` | Contains-match on business name (mode=byName); candidate name WITHOUT a designator (mode=availability) |
| `keywords` | array | `["Amazon"]` | 1-5 keywords, all must match (mode=byKeyword) |
| `entityIds` | array | – | Exact 10-digit entity IDs to look up (mode=byEntityId) |
| `entityTypeContains` | string | – | Case-insensitive substring filter on the full entity type (mode=byName, byKeyword) |
| `cityFilter` | string | – | Exact (case-insensitive) city match (mode=byName, byKeyword) |
| `maxItems` | int | `25` | Hard cap (1–200) |
| `proxyConfiguration` | object | AUTO proxy | Apify proxy config; always datacenter (AUTO), never residential |

#### Example: search by business name

```json
{
  "mode": "byName",
  "businessName": "Amazon",
  "entityTypeContains": "Limited Liability",
  "maxItems": 25
}
````

#### Example: check name availability

```json
{
  "mode": "availability",
  "businessName": "My Brand New Startup Idea"
}
```

#### Example: search by keywords

```json
{
  "mode": "byKeyword",
  "keywords": ["Amazon", "LLC"]
}
```

#### Example: lookup by exact entity ID(s)

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

### Use cases

- **New-business name clearance** — check whether a candidate name is available before filing
- **Vendor/customer due diligence** — confirm a business's entity ID, type, and incorporation date
- **Lead generation** — build lists of New Jersey-registered businesses by name or keyword
- **Company registry enrichment** — bulk-append New Jersey entity data to an existing business dataset
- **Legal & compliance research** — verify exact entity type (e.g. LLC vs. corporation) for a known entity ID

### FAQ

**Is this an official State of New Jersey product?**
No. This is an independent tool that uses the New Jersey Division of Revenue and Enterprise Services' own free, public, no-login business search.

**Why does `availability` mode reject names with `LLC`/`Inc`/`Corp` in them?**
That's the source's own validation rule — confirmed live. The availability check is meant to validate the base name before you choose a designator/entity type in the state's online filing system.

**Can I get a business's officers or registered agent?**
No — New Jersey's free search does not expose that data; see "What's NOT included" above.

**Why is there no `status` (active/inactive) field?**
New Jersey's free registered-business search doesn't return one — see "What's NOT included" above.

# Actor input Schema

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

What to fetch.

## `businessName` (type: `string`):

For mode=byName: name or partial name to search for, e.g. `Amazon` (contains match). For mode=availability: a candidate name WITHOUT a business designator (no `LLC`, `Inc`, `Corp`, etc. -- the source rejects those) to check whether it conflicts with an already-registered name.

## `keywords` (type: `array`):

1-5 keywords; results contain ALL of them (in any order) somewhere in the registered business name, e.g. `["Amazon", "LLC"]`.

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

Exact 10-digit New Jersey entity ID(s) to look up, e.g. `0450567823`.

## `entityTypeContains` (type: `string`):

Case-insensitive substring filter against the full entity type description, e.g. `Limited Liability` or `Corporation`. Leave blank for no filter.

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

Exact (case-insensitive) match against the registered business's on-file city. Leave blank for no filter.

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

Hard cap on emitted records. The source's registered-business searches return all matches in a single response (no server pagination); this cap is applied client-side.

## `proxyConfiguration` (type: `object`):

Uses Apify's free datacenter (AUTO) proxy group to get a fresh IP if a request is rate-limited by the source. Residential proxy is never used by this actor.

## Actor input object example

```json
{
  "mode": "byName",
  "businessName": "Amazon",
  "keywords": [
    "Amazon"
  ],
  "entityIds": [],
  "entityTypeContains": "",
  "cityFilter": "",
  "maxItems": 25,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped New Jersey business name / availability 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",
    "businessName": "Amazon",
    "keywords": [
        "Amazon"
    ],
    "entityIds": [],
    "entityTypeContains": "",
    "cityFilter": "",
    "maxItems": 25,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/new-jersey-dor-business-name-search-scraper").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",
    "businessName": "Amazon",
    "keywords": ["Amazon"],
    "entityIds": [],
    "entityTypeContains": "",
    "cityFilter": "",
    "maxItems": 25,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/new-jersey-dor-business-name-search-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "mode": "byName",
  "businessName": "Amazon",
  "keywords": [
    "Amazon"
  ],
  "entityIds": [],
  "entityTypeContains": "",
  "cityFilter": "",
  "maxItems": 25,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/new-jersey-dor-business-name-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/new-jersey-dor-business-name-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "New Jersey DOR Business Name Search Scraper",
        "description": "Search NJ's free public Business Name Search by name, keywords, or entity ID. Also checks business-name availability for new filings. Get business name, entity ID, entity type, city, incorporation date.",
        "version": "1.0",
        "x-build-id": "knlEcM4dg2w6cpDx4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~new-jersey-dor-business-name-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-new-jersey-dor-business-name-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~new-jersey-dor-business-name-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-new-jersey-dor-business-name-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~new-jersey-dor-business-name-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-new-jersey-dor-business-name-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "byName",
                            "byKeyword",
                            "byEntityId",
                            "availability"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "byName"
                    },
                    "businessName": {
                        "title": "Business name (mode=byName, availability)",
                        "type": "string",
                        "description": "For mode=byName: name or partial name to search for, e.g. `Amazon` (contains match). For mode=availability: a candidate name WITHOUT a business designator (no `LLC`, `Inc`, `Corp`, etc. -- the source rejects those) to check whether it conflicts with an already-registered name.",
                        "default": "Amazon"
                    },
                    "keywords": {
                        "title": "Keywords (mode=byKeyword)",
                        "type": "array",
                        "description": "1-5 keywords; results contain ALL of them (in any order) somewhere in the registered business name, e.g. `[\"Amazon\", \"LLC\"]`.",
                        "default": [
                            "Amazon"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "entityIds": {
                        "title": "Entity IDs (mode=byEntityId)",
                        "type": "array",
                        "description": "Exact 10-digit New Jersey entity ID(s) to look up, e.g. `0450567823`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "entityTypeContains": {
                        "title": "Entity type contains (mode=byName, byKeyword)",
                        "type": "string",
                        "description": "Case-insensitive substring filter against the full entity type description, e.g. `Limited Liability` or `Corporation`. Leave blank for no filter.",
                        "default": ""
                    },
                    "cityFilter": {
                        "title": "City filter (mode=byName, byKeyword)",
                        "type": "string",
                        "description": "Exact (case-insensitive) match against the registered business's on-file city. Leave blank for no filter.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Hard cap on emitted records. The source's registered-business searches return all matches in a single response (no server pagination); this cap is applied client-side.",
                        "default": 25
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Uses Apify's free datacenter (AUTO) proxy group to get a fresh IP if a request is rate-limited by the source. Residential proxy is never used by this actor.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
