# DC Business Registry - Entities, Trade Names, Beneficial Owners (`j0401/dc-business-registry`) Actor

Washington DC's business registry (public open data): 504K corporate registrations, 62K trade names and 491K beneficial owners, linked by file number so entity -> owners -> DBAs resolves on one id. Includes registered-agent details and the beneficial ownership layer DC publishes.

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

## Pricing

from $0.06 / 1,000 dc registry 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

## DC Business Registry - Entities, Trade Names, Beneficial Owners

### Low cost

**From $0.0001 per record, down to $0.00006 at Gold** - pay per record delivered, and nothing for the query. Cost scales with what you pull, not with the size of the register.

Washington DC's business registry, including the layer most registries do not publish: **beneficial owners**. Three linked datasets, resolved on one file number, so an entity, the trade names it operates under and the people who ultimately own it come back together.

### What you get

| Layer | Rows | What it holds |
|---|---|---|
| corporate | 504,036 | registered entities: status, entity type, domestic/foreign, full business address, registered agent with their own address |
| trade names | 62,088 | registered trade names / DBAs with effective and expiration dates |
| beneficial owners | 491,151 | the owners behind each entity, by name and address |

Entity status runs the full lifecycle - Revoked (314,701), Active - In Good Standing (116,121), Dissolved, Withdrawn, Merged, Terminated - and entity type covers 18 forms from LLCs and business corporations through nonprofits, limited partnerships and statutory trusts.

### Modes

- **corporate** (default) - registered entities
- **tradeName** - registered DBAs with their dates
- **beneficial** - the owners behind an entity
- **entity** - all three layers for one file number, in one response
- **aggregate** - counts by status, type, locale, state

### Example inputs

**Everything DC holds on one entity** - `mode=entity` keys on the file number
and returns the entity, its trade names and its beneficial owners together.

```json
{ "mode": "entity", "fileNumber": "240181", "maxResults": 200 }
```

**Owners behind LLCs**

```json
{ "mode": "beneficial", "businessName": "LLC", "maxResults": 50 }
```

**Trade names that have lapsed**

```json
{ "mode": "tradeName", "tradeNameStatus": "Expired", "maxResults": 50 }
```

**The registry by entity status** - one row per status.

```json
{ "mode": "aggregate", "corpus": "corporate", "groupBy": "entityStatus" }
```

### Why this is hard

The three layers do not spell their own join key the same way. The corporate layer calls it `FILE_NUMBER`; the beneficial-owners layer calls it `INITIALFILENUMBER`; the trade-name layer calls it `INITIAL_FILENUMBER`. One letter apart - and a mismatch returns nothing at all, silently, with no error. Four of the source's own address columns are misspelled (`BUSNIESS_ADDRESS_LINE1` through `BUSNIESS_ADDRESS_LINE4`) while the city and state columns are spelled correctly, so they all have to be mapped onto one field. The update stamp is raw epoch milliseconds rather than a date.

### Example output

**One entity** - `mode=corporate`, `fileNumber=240181` returns the registry row
below (a `mode=entity` pull adds the same entity's trade names and beneficial
owners):

```json
{
  "platform": "dc-registry",
  "source": "dc-dlcp-corporate",
  "corpus": "corporate",
  "recordKind": "entity",
  "mode": "corporate",
  "groupKey": "",
  "groupCount": "",
  "groupBy": "",
  "fileNumber": "240181",
  "entityStatus": "Dissolved",
  "locale": "Domestic",
  "modelType": "Domestic Nonprofit Corporation",
  "businessName": "! SI, SE PUEDE! BOSTON 2004 INC.",
  "address1": "",
  "address2": "",
  "address3": "",
  "address4": "",
  "city": "",
  "state": "",
  "zip": "",
  "country": "",
  "suffix": "",
  "registeredAgentName": "C T CORPORATION SYSTEM",
  "agentAddress1": "1015 15TH STREET NW",
  "agentAddress2": "Suite 1000",
  "agentAddress3": "",
  "agentAddress4": "",
  "agentCity": "Washington",
  "agentState": "DC",
  "agentZip": "20005",
  "tradeName": "",
  "tradeNameStatus": "",
  "effectiveDate": "",
  "tradeNameExpirationDate": "",
  "initialFileNumber": "",
  "lastModified": "",
  "ownerName": "",
  "ownerAddress": ""
}
```

**`mode=aggregate`, `corpus=corporate`, `groupBy=entityStatus`** - one row per
status, largest first:

```
Revoked                     314,701
Active - In Good Standing    116,121
```

### Output

One schema across all three layers, empty where a layer has nothing. Dates arrive as `YYYY-MM-DD`.

### Notes

- Public open data from DC's open-data ArcGIS service. No login, no scraping.
- DC publishes beneficial ownership as a matter of policy; this actor makes it queryable alongside the entity it belongs to.
- Charges are metered per record delivered, so pulling one entity's full record costs a fraction of a cent.

# Actor input Schema

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

corporate = registered entities (default). tradeName = registered trade names / DBAs. beneficial = the beneficial owners behind an entity. entity = EVERYTHING for one file number, in one response. aggregate = one count row per group.

## `corpus` (type: `string`):

Which layer to aggregate - only used when mode=aggregate. Ignored otherwise.

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

Aggregate dimension, only used when mode=aggregate. Valid per layer: corporate -> entityStatus, locale, modelType, state; tradeName -> tradeNameStatus; beneficial -> entityStatus, modelType, locale. Blank = a sensible default per layer. Blank = a sensible default for the selected table - do not leave it set when switching corpus.

## `fileNumber` (type: `string`):

Exact registry file number, e.g. 'L00005029230' or 'C00005497923'. One number links the entity, its trade names and its beneficial owners - this is the through-key. Blank = any. Use it with mode=entity to pull one entity's whole record.

## `name` (type: `string`):

Entity name substring (corporate layer only), e.g. 'LLC'. Blank = any.

## `entityStatus` (type: `string`):

Exact entity status (corporate / beneficial layers). Blank = any.

## `locale` (type: `string`):

Domestic = DC-formed; Foreign = out-of-state. Blank = any.

## `modelType` (type: `string`):

Exact entity type (corporate / beneficial layers). Blank = any.

## `tradeNameStatus` (type: `string`):

Exact trade-name status (tradeName layer only). Blank = any.

## `tradeName` (type: `string`):

Trade-name substring (tradeName layer only). Blank = any.

## `ownerName` (type: `string`):

Beneficial-owner name substring (beneficial layer only). Blank = any.

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

Entity-name substring on the beneficial-owners layer. Blank = any.

## `effectiveFrom` (type: `string`):

Earliest trade-name effective date, YYYY-MM-DD (tradeName layer only). Blank = any.

## `effectiveTo` (type: `string`):

Latest trade-name effective date, YYYY-MM-DD (tradeName layer only). Blank = any.

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

Cap records returned for this run. Default 50 keeps the daily auto-test fast. 0 = no cap (the full matching slice, up to 10,000).

## Actor input object example

```json
{
  "mode": "corporate",
  "corpus": "corporate",
  "groupBy": "",
  "fileNumber": "",
  "name": "",
  "entityStatus": "",
  "locale": "",
  "modelType": "",
  "tradeNameStatus": "",
  "tradeName": "",
  "ownerName": "",
  "businessName": "",
  "effectiveFrom": "",
  "effectiveTo": "",
  "maxResults": 50
}
```

# Actor output Schema

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

DC business registry 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/dc-business-registry").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/dc-business-registry").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/dc-business-registry --silent --output-dataset

```

## MCP server setup

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

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/FdTesdfeYlfggLzRJ/builds/HePw6537KxlShgNHj/openapi.json