# 🏛️ Delaware Corporations Search — DE Entity Registry (`nexgendata/delaware-corporations-search-scraper`) Actor

Search the Delaware Division of Corporations entity registry. For each entity name (partial match), returns matching DE entities — file\_number + entity\_name. KYC, AML compliance, VC sourcing, M\&A intelligence, journalism. Stripe Atlas + every DE C-corp incorporation appears here.

- **URL**: https://apify.com/nexgendata/delaware-corporations-search-scraper.md
- **Developed by:** [Stephan Corbeil](https://apify.com/nexgendata) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 de entity matches

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## 🏛️ Delaware Corporations Search Scraper — DE Entity Registry Lookup

Search the **Delaware Division of Corporations** entity registry — the canonical source of every Delaware-incorporated business. By name (partial match) returns matching entities with their state-issued file number and exact registered name.

Delaware is the legal home of two-thirds of all Fortune 500 companies, virtually every YC C-corp (Stripe Atlas defaults to DE), and the lion's share of US LLCs / LPs / LLPs. If you need to verify a counterparty exists, hunt brand-new C-corp incorporations before they appear on Crunchbase, or catch shell-company patterns — the DE Division of Corporations is where the truth lives.

---

### What you get per match

Each dataset row is one Delaware-incorporated entity match:

- **`search_query`** — the input string that matched
- **`file_number`** — the official Delaware-assigned file number (numeric, the system of record)
- **`entity_name`** — the canonical entity name as registered in DE (uppercase, exact legal entity name including suffix like `INC.`, `LLC`, `L.P.`, `L.L.C.`)
- **`state_of_formation`** — `DE` (passthrough — useful when you union this dataset with other state-registry actors)
- **`source`** — `icis.corp.delaware.gov`

> **Note:** the free public name search returns `file_number` + `entity_name`. Full entity detail (registered agent, status, formation date, entity type) requires a CAPTCHA-protected detail-page step that is not part of this Actor. If you need detail-page data, you can take the `file_number` returned here and run an order via Delaware's official paid API or use a downstream registered-agent service. For directory-listing use cases (KYC, journalism, sourcing, deduping a contact list) the `file_number` + `entity_name` pair is usually all you need.

---

### 6 use cases

1. **VC associate / pre-seed sourcing** — A new Stripe Atlas C-corp filing shows up in DE *before* Crunchbase has heard of the company. Search every founder's last name + product name; the DE filing date is the earliest signal a startup exists. Beats Crunchbase, beats LinkedIn, beats every other paid signal.
2. **KYC / AML compliance** — Verify that a counterparty entity actually exists in Delaware as registered. Cross-check the `file_number` with the company's W-9 / EIN paperwork. If the entity name doesn't return any DE match, that's a red flag.
3. **M&A diligence / target lists** — Hunt every entity matching a parent company's brand keyword to find subsidiaries, holding companies, and SPVs that all incorporate under variations of the parent's name.
4. **Journalism / shell company tracking** — Reporters investigating shell companies, LLCs tied to political donors, or PE-firm portfolio companies frequently use the DE search as the discovery layer (then escalate via paid registered-agent services for the detail).
5. **Lawyer / paralegal litigation prep** — Before suing or sending a demand letter, confirm the defendant is actually a registered DE entity and grab the official legal name + file number for the complaint caption.
6. **Real-estate / counterparty deduping** — Roll up multiple variations of `Acme Properties LLC` / `Acme Holdings LLC` / `Acme Capital, L.P.` to a clean canonical legal-entity list with file numbers as the dedupe key.

---

### Quick start (JSON input)

```json
{
  "entityNames": ["Stripe", "Apple Inc", "Acme"],
  "maxEntities": 200
}
````

Each name is a partial-match search; results union into a single dataset.

### Python SDK

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("nexgendata/delaware-corporations-search-scraper").call(run_input={
    "entityNames": ["Stripe", "OpenAI"],
    "maxEntities": 100,
})
for ent in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{ent['file_number']} — {ent['entity_name']}")
```

### cURL

```bash
curl "https://api.apify.com/v2/acts/nexgendata~delaware-corporations-search-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"entityNames":["OpenAI"],"maxEntities":50}'
```

### Integrations

Pipe results to **Zapier**, **Make.com**, or **n8n**. Common pairings: Salesforce / HubSpot CRM enrichment when you want to verify an account's legal name + file number; deduping a vendor master list; KYC pipelines via Snowflake / BigQuery.

***

### Pricing (Pay Per Event)

| Event | Price |
|---|---|
| Actor start | **$0.00005** |
| Per entity match returned | **$0.10** |

**Cost calculator:**

- 50 matches (a single deep search like "Acme") = **$5.00**
- 200 matches (a small KYC batch) = **$20.00**
- 500 matches = **$50.00**
- 2,000 matches (a large diligence sweep) = **$200.00**

Compare to LexisNexis (~$25–$100/document for entity reports), CT Corporation registered-agent services ($100s per lookup), or a paralegal hour ($75–$150/hour). For directory-listing intel this Actor is two orders of magnitude cheaper.

***

### FAQ

**Is this the official Delaware Division of Corporations API?** No. Delaware does not publish a free public API for entity search. We submit the same form a human would on `icis.corp.delaware.gov/Ecorp/EntitySearch/NameSearch.aspx` (the official ASP.NET WebForms search) and parse the result table.

**Why not return registered agent + entity type + status?** Those fields live on the entity-detail page, which is gated behind a CAPTCHA challenge. Capturing detail data from Delaware is not feasible without their paid commercial API. The free directory listing — file\_number + entity\_name — is what this Actor delivers and is usually enough for the use cases above.

**How does partial matching work?** A search for `Stripe` returns every DE entity whose name contains "STRIPE" — including unrelated entities like `STRIPED BASS L.L.C.`. Refine with longer queries (e.g. `Stripe Inc` or `Stripe Capital`) for tighter results, or filter the result set client-side.

**Are queries case-sensitive?** No — Delaware normalizes search input to upper-case.

**What if my search returns nothing?** Either the entity isn't registered in DE, the name was misspelled, or the entity is filed in another US state (Wyoming, Nevada, etc). Each DE-only result with `state_of_formation: DE` confirms that specific entity is incorporated in Delaware.

**Is this dataset commercially usable?** The Delaware DOC public search results are public records issued by a state government. We respect the site's free-access tier (single-threaded, ~500ms between searches). Confirm your specific commercial use case with your legal team if you plan to redistribute the data.

***

### Related actors

- 📑 [SEC Form D Scraper](https://apify.com/nexgendata/sec-form-d-scraper) — Form D private placements, often filed by the same DE entities you find here
- 🪙 [Startup Funding Tracker](https://apify.com/nexgendata/startup-funding-tracker) — funding rounds + investor data downstream of the DE incorporation event
- 🔍 [SEC EDGAR Search](https://apify.com/nexgendata/sec-edgar-search) — surface every public filing tied to a company once you have its name

***

[Try this Actor on Apify →](https://apify.com/nexgendata/delaware-corporations-search-scraper) | [Get a free Apify account →](https://apify.com/nexgendata?fpr=2ayu9b)

# Actor input Schema

## `entityNames` (type: `array`):

List of entity name strings to search. Partial-match — 'Stripe' matches 'STRIPE 5 DELAWARE L.P.', 'STRIPE-A-LOT, INC.', etc. Each search returns up to ~50 matching entities. Multiple strings = multiple searches.

## `maxEntities` (type: `integer`):

Hard cap on total entities returned across ALL searches in this run (1–2000). Each entity is one dataset row.

## Actor input object example

```json
{
  "entityNames": [
    "Stripe"
  ],
  "maxEntities": 5
}
```

# 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 = {
    "entityNames": [
        "Stripe"
    ],
    "maxEntities": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/delaware-corporations-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 = {
    "entityNames": ["Stripe"],
    "maxEntities": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/delaware-corporations-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 '{
  "entityNames": [
    "Stripe"
  ],
  "maxEntities": 5
}' |
apify call nexgendata/delaware-corporations-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/delaware-corporations-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🏛️ Delaware Corporations Search — DE Entity Registry",
        "description": "Search the Delaware Division of Corporations entity registry. For each entity name (partial match), returns matching DE entities — file_number + entity_name. KYC, AML compliance, VC sourcing, M&A intelligence, journalism. Stripe Atlas + every DE C-corp incorporation appears here.",
        "version": "0.0",
        "x-build-id": "nTd2npZfC6djcQ91G"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~delaware-corporations-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-delaware-corporations-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/nexgendata~delaware-corporations-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-delaware-corporations-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/nexgendata~delaware-corporations-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-delaware-corporations-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": [
                    "entityNames"
                ],
                "properties": {
                    "entityNames": {
                        "title": "Entity name searches",
                        "type": "array",
                        "description": "List of entity name strings to search. Partial-match — 'Stripe' matches 'STRIPE 5 DELAWARE L.P.', 'STRIPE-A-LOT, INC.', etc. Each search returns up to ~50 matching entities. Multiple strings = multiple searches.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEntities": {
                        "title": "Max entities (across all searches)",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on total entities returned across ALL searches in this run (1–2000). Each entity is one dataset row.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
