# Delaware Corporation Search Scraper (`automation-lab/delaware-corporations-search-scraper-v2`) Actor

Search Delaware corporations by name or file number and export entity identity, formation, and registered-agent details for KYB and due diligence.

- **URL**: https://apify.com/automation-lab/delaware-corporations-search-scraper-v2.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Corporation Search Scraper

Search the official Delaware Division of Corporations registry and turn public entity pages into structured records for company due diligence and KYB enrichment.

Enter company names or Delaware file numbers. The Actor returns entity identity, formation, legal type, residency, and registered-agent details in a dataset ready for spreadsheets, APIs, and scheduled workflows.

### What this Delaware corporation search Actor does

The Actor automates the public ICIS entity-search workflow at `icis.corp.delaware.gov`:

1. Opens a valid US residential browser session.
2. Searches by partial or exact entity name, or by Delaware file number.
3. Opens each matching public entity detail page.
4. Normalizes the free entity and registered-agent fields.
5. Deduplicates records by Delaware file number.
6. Saves results to the run's default dataset.

It uses the official public search rather than a stale third-party company list.

### Who is it for?

- **KYB and compliance teams** enriching a list of prospective counterparties.
- **Investment and M\&A analysts** confirming entity identity and formation details.
- **Sales operations teams** resolving company names to Delaware file numbers.
- **Legal operations teams** collecting public registered-agent details for review.
- **Journalists and researchers** investigating a bounded set of Delaware entities.
- **Data engineers** feeding normalized public registry fields into an internal pipeline.

### Why use this Actor

- Supports both **name discovery** and **precise file-number lookup**.
- Retrieves detail fields, not only names from the search-result list.
- Supports exact-name matching for cleaner entity resolution.
- Uses coherent browser, proxy, cookie, and ASP.NET postback sessions.
- Rotates sessions after bounded transient failures.
- Applies a global `maxItems` cap and deduplicates across searches.
- Produces typed records with query provenance and scrape timestamps.

### What data is extracted

| Field | Meaning |
| --- | --- |
| `fileNumber` | Delaware Division of Corporations file number |
| `entityName` | Legal entity name returned by the registry |
| `formationDate` | Incorporation or formation date shown by the source |
| `entityKind` | Broad legal kind, such as Corporation or Limited Liability Company |
| `entityType` | Registry subtype, such as General |
| `residency` | Domestic or foreign residency classification |
| `state` | State or jurisdiction shown on the entity record |
| `registeredAgent.name` | Registered-agent name |
| `registeredAgent.address` | Registered-agent street address |
| `registeredAgent.city` | Registered-agent city |
| `registeredAgent.county` | Registered-agent county |
| `registeredAgent.state` | Registered-agent state |
| `registeredAgent.postalCode` | Registered-agent postal code |
| `registeredAgent.phone` | Registered-agent phone, when available |
| `matchedBy` | Whether the record came from a name or file-number search |
| `searchQuery` | Original input value that produced the record |
| `sourceUrl` | Official registry search URL |
| `scrapedAt` | UTC extraction timestamp |

A field can be `null` when the official page does not provide it.

### How to search Delaware corporations

1. Open the Actor in Apify Console.
2. Add one or more values under **Entity names** or **Delaware file numbers**.
3. Enable **Exact name match** when you already know the complete legal name.
4. Set **Maximum records** to the number your workflow needs.
5. Click **Start**.
6. Open the **Delaware entities** dataset view or export it as JSON, CSV, Excel, XML, or RSS.

A useful first run is:

```json
{
  "searchTerms": ["OpenAI"],
  "maxItems": 3
}
```

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `searchTerms` | `string[]` | `[]` | Full or partial legal entity names |
| `fileNumbers` | `string[]` | `[]` | Delaware file numbers for precise lookups |
| `exactMatch` | `boolean` | `false` | Applies the source's quoted exact-name search |
| `maxItems` | integer | `50` | Global output cap from 1 to 500 |
| `maxRetries` | integer | `2` | Fresh residential sessions after a transient failure, from 0 to 4 |

At least one name or file number is required. A run accepts at most 20 combined searches.

### Output example

A current entity detail record has this shape:

```json
{
  "fileNumber": "10150317",
  "entityName": "OPEN AI CHEAT CODES INC.",
  "formationDate": "3/31/2025",
  "entityKind": "Corporation",
  "entityType": "General",
  "residency": "Domestic",
  "state": "DELAWARE",
  "registeredAgent": {
    "name": "UNITED STATES CORPORATION AGENTS, INC.",
    "address": "131 CONTINENTAL DRIVE SUITE 305",
    "city": "NEWARK",
    "county": "New Castle",
    "state": "DE",
    "postalCode": "19713",
    "phone": "302-777-0538"
  },
  "matchedBy": "fileNumber",
  "searchQuery": "10150317",
  "sourceUrl": "https://icis.corp.delaware.gov/Ecorp/EntitySearch/NameSearch.aspx",
  "scrapedAt": "2026-08-01T02:24:00.000Z"
}
```

Registry values can change. Treat every extraction as a time-stamped observation.

### How much does it cost to search Delaware corporations?

The Actor uses pay-per-event pricing:

- one `start` event per run;
- one `item` event for each unique entity record saved;
- six decreasing volume tiers for item events.

The start event is **$0.005**. Item prices decrease by Apify plan tier:

| Tier | Price per saved entity |
| --- | ---: |
| FREE | $0.092 |
| BRONZE | $0.08 |
| SILVER | $0.0624 |
| GOLD | $0.048 |
| PLATINUM | $0.032 |
| DIAMOND | $0.0224 |

The total is the one-time start fee plus the active tier price for each saved record. At BRONZE pricing, 1 record costs **$0.085**, 10 records cost **$0.805**, and 100 records cost **$8.005**. Empty and duplicate records are not charged as item events.

Residential proxy and browser infrastructure are included in the Actor's event economics; there is no separate proxy input. The Console shows your applicable live tier before each run.

### Name-search strategies

#### Partial discovery

Use a distinctive name fragment and `exactMatch: false`. The Delaware source currently returns at most 50 matches per query, so broad words may need refinement.

#### Exact entity resolution

Set `exactMatch: true` and submit the complete legal name, including suffixes such as `INC.` or `LLC` when known.

#### File-number verification

Use `fileNumbers` when another system already stores a Delaware identifier. This is the narrowest and most predictable lookup route.

### KYB enrichment workflow

A practical recurring workflow is:

1. Export candidate legal names from your CRM or onboarding system.
2. Send up to 20 names in one Actor input.
3. Review ambiguous partial-name matches.
4. Join the output to your source table using `searchQuery` and `fileNumber`.
5. Store `scrapedAt` so reviewers know when the registry was checked.
6. Schedule a later run if your policy requires periodic re-verification.

The Actor does not calculate a risk score or declare an entity verified. Those decisions belong to your compliance process.

### Scheduling and monitoring

Use an Apify Schedule for recurring checks. Export or load each run's dataset into your own warehouse and compare records by `fileNumber`.

The Actor reports current public fields. It does not maintain history or emit change alerts by itself; use Apify integrations, webhooks, or your database to compare runs.

### Export and integrations

Default dataset results can be:

- downloaded as JSON, CSV, Excel, XML, or RSS;
- sent to Google Sheets through an Apify integration;
- delivered by webhook after a successful run;
- loaded into Make, Zapier, n8n, Airbyte, or a custom ETL job;
- queried with the Apify API or client libraries.

Each run uses its own default dataset, so results from earlier runs are not mixed into current output.

### Run with the Apify API

Set `APIFY_TOKEN` in your environment.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~delaware-corporations-search-scraper-v2/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms":["OPENAI GLOBAL, LLC"],"exactMatch":true,"maxItems":1}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/delaware-corporations-search-scraper-v2').call({
    fileNumbers: ['10150317'],
    maxItems: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/delaware-corporations-search-scraper-v2').call(
    run_input={'searchTerms': ['OpenAI'], 'maxItems': 3}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/delaware-corporations-search-scraper-v2"
```

#### Claude Desktop setup

Add this server object to the Claude Desktop MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/delaware-corporations-search-scraper-v2"
    }
  }
}
```

#### Cursor setup

Add the same `mcpServers.apify` URL to Cursor's MCP settings, then enable the Apify server for your project.

#### VS Code setup

Add the same HTTP endpoint to your VS Code MCP server configuration and start the `apify` server from the MCP tools panel.

Example prompts:

- “Look up Delaware file number 10150317 and summarize the entity and registered agent.”
- “Search Delaware entities for OpenAI and return the first five records as a table.”
- “Resolve these exact Delaware legal names and prepare a KYB enrichment CSV.”

### Limits and source behavior

- The official source caps a name search at 50 displayed matches.
- Broad queries may omit matches beyond that cap; refine the name or use file numbers.
- The source can reject a browser session. The Actor retries with a fresh US residential session up to `maxRetries` times.
- Source maintenance, rate limits, or markup changes can cause a run to fail rather than return misleading empty data.
- Detail extraction is intentionally conservative and can take longer than a list-only scraper.
- A maximum of 20 searches and 500 saved records is enforced per run.

### Status and certificate limitation

The Delaware free search states that its results are **not a statement of good standing**. Current status, certificates, franchise-tax assessments, filing history, and paid documents are not included in this Actor.

Do not interpret presence in the dataset as proof that an entity is active, compliant, or in good standing. Obtain official paid documents through authorized Delaware channels when your decision requires them.

### Legality and responsible use

The Delaware source prohibits excessive automated mining. Use this Actor for bounded entity searches, keep `maxItems` appropriate to a real due-diligence job, and avoid splitting broad bulk extraction into repeated runs.

Public registry data can include contact information. Handle it under applicable privacy, data-retention, and fair-use rules. This Actor is a data-extraction tool, not legal or compliance advice.

### Troubleshooting

#### Why did my run return no records?

Check spelling and legal suffixes, disable exact matching, or search by file number. A successful zero-row run means the source explicitly returned “No Records Found.”

#### Why did the run fail with a source-session message?

The official site did not provide a usable search session after the configured retries. Retry later rather than launching many immediate runs. The Actor fails closed instead of presenting a challenge page as valid empty output.

#### Why do I see only 50 matches?

That is the official name-search result cap. Use a more specific name, exact matching, or file-number lookup.

#### Does this Actor prove good standing?

No. The free source explicitly disclaims that interpretation. Use an official certificate or paid status service for that purpose.

### Frequently asked questions

#### Can I search several companies at once?

Yes. Add multiple values to `searchTerms` and/or `fileNumbers`, up to 20 combined searches. `maxItems` applies across the entire run.

#### Are duplicate entities charged twice?

No. Results are deduplicated by Delaware file number before saving and item charging.

#### Is a proxy configuration required in the input?

No. The Actor manages the US residential session required by the source.

#### Can I retrieve filing history or tax balances?

No. Those are paid Delaware services and are outside this Actor's free public-data scope.

### Related Actors

Explore other public-record and due-diligence tools from [automation-lab on Apify](https://apify.com/automation-lab). Choose a source-specific Actor that matches the jurisdiction and record type your workflow requires.

### Support

If a valid, bounded search repeatedly fails, open an Actor issue with:

- a redacted input;
- the run URL;
- the approximate failure time;
- whether the same search works manually on the Delaware site.

Do not include private customer lists or credentials in support messages.

# Actor input Schema

## `searchTerms` (type: `array`):

One or more full or partial Delaware entity names. Up to 20 combined name and file-number searches per run.

## `fileNumbers` (type: `array`):

Optional Delaware entity file numbers for precise lookups.

## `exactMatch` (type: `boolean`):

Wrap name searches in quotation marks so the source applies exact-name matching.

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

Maximum number of unique entity detail records saved across all searches.

## `maxRetries` (type: `integer`):

Number of fresh residential browser sessions tried after a transient source or session failure.

## Actor input object example

```json
{
  "searchTerms": [
    "OpenAI"
  ],
  "fileNumbers": [],
  "exactMatch": false,
  "maxItems": 10,
  "maxRetries": 2
}
```

# Actor output Schema

## `overview` (type: `string`):

Open all extracted entity records in the overview table.

# 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 = {
    "searchTerms": [
        "OpenAI"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/delaware-corporations-search-scraper-v2").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 = {
    "searchTerms": ["OpenAI"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/delaware-corporations-search-scraper-v2").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 '{
  "searchTerms": [
    "OpenAI"
  ],
  "maxItems": 10
}' |
apify call automation-lab/delaware-corporations-search-scraper-v2 --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/VFc5gzxE0nCwujKCx/builds/mApxcBhyQhiQAf7d5/openapi.json