# NY Attorney Registrations - New York Lawyer Directory (`j0401/ny-attorney-registrations`) Actor

New York State attorney register (public open data, 434k attorneys): admission year, firm, office address, admission department, law school, registration status and next re-registration. Verify a lawyer, screen status, or profile the bar. Filter by name, firm, city or status.

- **URL**: https://apify.com/j0401/ny-attorney-registrations.md
- **Developed by:** [Wenhao Yang](https://apify.com/j0401) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 new york attorney 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

## NY Attorney Registrations - New York Lawyer Directory

The register of attorneys admitted to practise in New York, straight from the
NYS Unified Court System. **434,394 attorneys**, each with admission year, firm,
office location, law school and current registration status.

### Low cost

**From $0.00005 per record, down to $0.00003 at Gold.** Pay only for the
records you actually receive - the whole register stays queryable, you are
never billed for the scan behind it.

### What you get

One row per registered attorney:

- **Identify** - registration number, first / middle / last name, suffix
- **Where they practise** - the firm or company, and the office street, city,
  state, ZIP and county
- **When admitted** - year of admission and the judicial department of
  admission (1st-4th)
- **Credentials** - the law school
- **Standing** - the registration status, and the next re-registration window

That is the full record the court system publishes: who the attorney is, where
they work, when they were admitted, where they studied, and whether they stand
in good order.

### Filter it

- **Name** - `lastName="Goldberg"`, `firstName="Sarah"`.
- **Firm** - `firm="Sidley"`, `firm="Legal Aid"`.
- **Place** - `city="Buffalo"`, `county="Kings"`.
- **Law school** - `lawSchool="Harvard"`.
- **Admission year** - `yearFrom=2000`, `yearTo=2026`.
- **Status** - `status="Currently registered"` for the practising set, or
  `status="Disbarred"` for the disciplinary outcome.

### Example inputs

**Verify one attorney** - `lastName` is a substring match.

```json
{ "lastName": "COHEN", "firstName": "DAVID", "maxResults": 25 }
```

**Everyone at one firm** - firm names are free text as filed.

```json
{ "firm": "LEGAL AID SOCIETY", "status": "Currently registered", "maxResults": 50 }
```

**A recent cohort** - admitted this year.

```json
{ "yearFrom": 2026, "maxResults": 50 }
```

**Where the bar sits** - `mode=aggregate` returns one count row per status;
every group comes back.

```json
{ "mode": "aggregate", "groupBy": "status" }
```

### Or roll it up

Set `mode=aggregate` and get a rolled-up count by **status**, **county**,
**judicial department** or **admission year**. Every group comes back - this
mode is not cut off by `maxResults`.

### Then use it

- **Verify** a lawyer's registration number and current standing.
- **Screen** a counterparty's counsel against the disciplinary outcomes
  (disbarred, suspended, resigned).
- **Map** the bar: active attorneys by city, county or admission year.
- **Find** every attorney at a firm, or every hire from a law school.

### Example output

**One attorney record** - registration 6368591:

```json
{
 "platform": "ny-attorney-registrations",
 "source": "nys-attorney-registrations",
 "mode": "rows",
 "groupKey": "",
 "groupCount": "",
 "groupBy": "",
 "registrationNumber": "6368591",
 "firstName": "JOSHUA",
 "middleName": "W.",
 "lastName": "JOSEY",
 "suffix": "",
 "firm": "UNII",
 "street1": "99 WALL ST # 201",
 "street2": "",
 "city": "NEW YORK",
 "state": "NY",
 "zip": "10005",
 "zipPlusFour": "4301",
 "country": "UNITED STATES OF AMERICA",
 "county": "New York",
 "yearAdmitted": "2026",
 "judicialDepartment": "1",
 "lawSchool": "City University of New York School of Law",
 "status": "Currently registered",
 "nextRegistration": "Oct 2028",
 "sourceUpdatedAt": "2026-10-07"
}
```

**`mode=aggregate`, `groupBy=status`** - one count row per status:

```
Currently registered                           292,779
Deceased                                        49,419
Due to reregister within 30 days of birthday    42,678
Suspended, delinquent                           20,198
Delinquent                                      15,391
Resigned                                         7,172
```

### Notes on the data, from the source

- **This is every attorney ever admitted, not just the practising ones.** The
  `status` column carries the outcome - `Currently registered` (292,779),
  `Deceased` (49,419), `Disbarred` (2,191) and more. A query that means
  "practising lawyers" should pass `status="Currently registered"`.
- **County is blank on about 62% of rows.** It is offered as a filter and a
  group-by dimension, but it is not a required field.
- **Firm and law-school names are free text as filed**, so a substring match is
  the right way to search them.
- **The register is refreshed on the court system's cycle**; `sourceUpdatedAt`
  carries the dataset's own refresh date.
- **Office phone numbers are deliberately not included** - the register is a
  professional directory, and the direct-dial number adds nothing to a
  credential check.

# Actor input Schema

## `lastName` (type: `string`):

Substring match on the attorney's last name, e.g. 'SMITH', 'GOLDBERG', 'CHEN'. Blank = any.

## `firstName` (type: `string`):

Substring match on the attorney's first name. Blank = any.

## `firm` (type: `string`):

Substring match on the firm or organisation the attorney practises through, e.g. 'SIDLEY', 'MORRISON FOERSTER'. Free text as filed with the court system. Blank = any.

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

Substring match on the office city, e.g. 'NEW YORK', 'BUFFALO'. Blank = any.

## `county` (type: `string`):

Substring match on the county, e.g. 'Kings', 'Erie'. Note: county is blank on about 62% of rows, so a county filter narrows to the subset that reports one. Blank = any.

## `lawSchool` (type: `string`):

Substring match on the law school, e.g. 'HARVARD', 'FORDHAM', 'COLUMBIA'. Blank = any.

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

Exact registration status. 'Currently registered' (292,779) is the practising set; the register also carries the deceased, disbarred, resigned and delinquent. Blank = any.

## `yearFrom` (type: `integer`):

Earliest year of admission, e.g. 2000. Blank = any. Years run 1898-2026.

## `yearTo` (type: `integer`):

Latest year of admission, e.g. 2026. Blank = any.

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

rows = attorney records matching your filters (default). aggregate = one count row per group (see groupBy).

## `groupBy` (type: `string`):

Which dimension to aggregate over (mode=aggregate). Blank = status. Every group is returned - aggregate mode is not cut off by maxResults. lawSchool is deliberately not offered here (it is high-cardinality free text and would be truncated).

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

Cap the number of records pushed in rows mode (0 = default 50; up to 2,000 per run). Each record is metered individually, so there is no per-run charge cap. Aggregate mode returns every group.

## Actor input object example

```json
{
  "lastName": "",
  "firstName": "",
  "firm": "",
  "city": "",
  "county": "",
  "lawSchool": "",
  "status": "",
  "mode": "rows",
  "groupBy": "",
  "maxResults": 50
}
```

# Actor output Schema

## `recordsUrl` (type: `string`):

New York attorney registration records - as JSON

## `datasetUrl` (type: `string`):

No description

## `runUrl` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("j0401/ny-attorney-registrations").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("j0401/ny-attorney-registrations").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 '{}' |
apify call j0401/ny-attorney-registrations --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,j0401/ny-attorney-registrations"
        }
    }
}
```

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/ezPgYlIziGYGSaXcH/builds/lOr01Hr7VL1L0kGc8/openapi.json