# Vermont SOS Business Registration Search Scraper (`crawlerbros/vermont-sos-business-search-scraper`) Actor

Verify one or more companies against Vermont's Secretary of State Business Registration registry by exact name. Returns entity status, entity type, entity number, name-change history, and registered-agent history.

- **URL**: https://apify.com/crawlerbros/vermont-sos-business-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 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

## Vermont SOS Business Registration Search Scraper

Verify companies against **Vermont's Secretary of State Business Registration registry** (bizfilings.vermont.gov) — the official record of every corporation, LLC, limited partnership, and nonprofit registered to do business in Vermont. Provide one or more exact (or near-exact) registered business names and get back each entity's full registration detail: status, entity type, incorporation date, registered agent, officers/directors, annual-report status, NAICS codes, addresses, name-change history, and registered-agent change history. No login or API key required.

### What this actor does

- **Batch business-name verification** — check one or many company names against Vermont's registry in a single run
- **Full registration detail per entity** — email, incorporation date, annual-report due/filed dates and status, NAICS industry codes, structured physical and mailing addresses, and (for foreign entities) home-state/country of incorporation
- **Registered agent** — name, address, email, and phone of the entity's registered agent of record
- **Officers & directors** — every on-file principal's name, title, and address
- **DBA / assumed-name ownership** — for Assumed Name filings, the parent business that owns the DBA
- **19+ entity status values** and **19 business/entity types** available as post-search filters (e.g. `Active - In Good Standing`, `Dissolved`, `Domestic Business Corporation`, `Foreign Limited Liability Company`)
- **Legal name-change history** — every previous registered name and the date it changed, when on file
- **Registered-agent change history** — every prior registered agent, when on file
- **Empty fields are omitted** — a field only appears on a record when the registry actually has that value on file

### How name matching works

Vermont's registry matches business names against a normalized "core name" (punctuation and common legal-entity words like "Inc.", "LLC", "Corporation", "Company" are stripped from both your query and every registered name before comparing) — **this is an exact/near-exact lookup on that stripped core name, not a fuzzy or arbitrary partial-word search.** For best results:

- Use the company's full legal name — including or omitting designators like "Corporation", "Company", "Inc.", or "LLC" both work, since they're stripped either way (e.g. searching `"Apple"` and `"Apple Inc."` return the same match)
- Every other word in the name must still be present — dropping a distinguishing word (e.g. searching `"Ben & Jerry"` instead of `"Ben & Jerry's Homemade, Inc."`) will not match
- Because legal-entity words are stripped, a short/generic query can occasionally match a business whose *entire* name reduces to that same word once its own designators are stripped (e.g. searching `"Vermont"` alone matches a real business named "Vermont Service Corporation", since "Service" and "Corporation" are both stripped from its registered name) — always use the company's full, specific name to avoid this

### Output per business entity

- `idBusiness` — internal registry ID
- `businessName`
- `entityNumber` — Vermont business ID number
- `legEntityNumber` — Vermont's secondary/legacy filing number, when on file
- `status` — e.g. `Active - In Good Standing`, `Dissolved`, `Withdrawn`
- `entityType` — e.g. `Domestic Business Corporation`, `Foreign Limited Liability Company`
- `emailAddress` — the entity's on-file contact email, when on file
- `dateOfIncorporation` — date the entity was formed/registered (YYYY-MM-DD)
- `businessExpirationDate` — expiration date, for time-limited registrations (e.g. some Assumed Name filings)
- `dissolvedDate` — date the entity was dissolved, when on file
- `terminationDate` — date the entity's registration was terminated, when on file
- `fiscalYearMonth` — the entity's fiscal year-end month (1-12), when on file
- `physicalAddress`, `mailingAddress` — full principal/mailing addresses, when on file
- `otherAddress` — an additional address the registry keeps on file for this entity (commonly the Vermont-specific office address for a foreign/out-of-state entity), only included when it differs from `physicalAddress`/`mailingAddress`
- `annualReportDueDate`, `annualReportStatus`, `lastAnnualReportFiledDate` — Vermont annual-report compliance status
- `foreignJurisdictionState`, `foreignJurisdictionCountry` — home state/country of incorporation, for Foreign entities
- `naicsCodes[]` — NAICS industry classification description(s) on file
- `businessPurpose` — the entity's stated business purpose/tax provision, when on file
- `registeredAgentName`, `registeredAgentAddress`, `registeredAgentEmail`, `registeredAgentPhone` — the entity's current registered agent of record
- `officers[]` — `{ fullName, title, address }` for every on-file officer, director, or other principal (toggle with `includeOfficers`)
- `assumedNames[]` — DBA / assumed names filed under this entity, when on file
- `ownedByBusinessName`, `ownedByEntityNumber` — for Assumed Name filings, the parent business that owns the DBA
- `address` — the raw list-search address field (Vermont's registry populates this on very few records; `physicalAddress`/`mailingAddress` above are the reliable source)
- `searchableName` — the registry's normalized name used for matching
- `matchedQuery` — the business name you searched for that produced this match
- `nameHistory[]` — `{ previousName, distinguishableName, effectiveStartDate, endDate, filingId }` for every prior legal name, when on file
- `agentHistory[]` — `{ agentName, address, effectiveStartDate, endDate }` for every prior registered agent, when on file
- `sourceUrl`, `recordType: "business"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `businessNames` | array of strings | – | One or more exact (or near-exact) Vermont-registered business names (required) |
| `statusFilter` | string | – | Filter to one of 19+ exact entity status values |
| `businessTypeFilter` | string | – | Filter to one of 19 exact business/entity types |
| `includeNameHistory` | boolean | `true` | Fetch legal name-change history per matched entity |
| `includeAgentHistory` | boolean | `true` | Fetch registered-agent change history per matched entity |
| `includeOfficers` | boolean | `true` | Include the entity's on-file officers/directors/principals |
| `maxItems` | integer | `20` | Maximum number of business entity records to return (1–200) |

#### Example: verify a single company

```json
{
  "businessNames": ["Ben & Jerry's Homemade, Inc."]
}
```

#### Example: batch-verify several companies

```json
{
  "businessNames": [
    "Ben & Jerry's Homemade, Inc.",
    "Walmart Inc.",
    "Apple Inc.",
    "Vermont Teddy Bear Company, Inc."
  ],
  "maxItems": 50
}
```

#### Example: verify and filter to active entities only, skip history (fastest)

```json
{
  "businessNames": ["Ben & Jerry's Homemade, Inc.", "Walmart Inc."],
  "statusFilter": "Active - In Good Standing",
  "includeNameHistory": false,
  "includeAgentHistory": false,
  "includeOfficers": false
}
```

### Use cases

- **Business verification / KYC** — confirm a counterparty's Vermont registration status, entity type, and registered agent before signing a contract
- **Portfolio compliance monitoring** — batch-check a list of companies for status changes (dissolutions, withdrawals, revocations) and annual-report compliance
- **Due diligence** — review a company's officers/directors, legal name-change history, and registered-agent history
- **Lead/vendor onboarding** — verify a vendor or customer is in good standing in Vermont
- **Corporate research** — look up a company's officers, registered agent, and NAICS industry classification

### FAQ

**Do I need an API key or login?**
No. The actor queries Vermont's public Business Registration search API, which requires no account.

**Why did my search return no results?**
Vermont's registry requires an exact (or near-exact) registered name — see "How name matching works" above. Double-check the company's exact legal name, including its entity designator (Corporation, Company, LLC, etc.).

**Why are some fields missing from a record?**
Only fields the registry actually has on file are included — this actor never fills in placeholder or guessed values. Most businesses have no `nameHistory` or `agentHistory` entries (they've never changed name or agent), so those fields are simply omitted rather than returned empty.

**Can I search by registered agent name or use advanced filters like formation date?**
Not currently — Vermont's advanced search and registered-agent search both require a logged-in account on the source site (confirmed via direct testing: they return an authentication error to anonymous requests). This actor only uses the registry's public, unauthenticated business-name lookup.

**Is this actor reliable?**
Yes. It queries Vermont's public business registration search directly and automatically retries transient errors, so temporary hiccups on the source site don't cause a failed run.

# Actor input Schema

## `businessNames` (type: `array`):

One or more exact (or near-exact) Vermont-registered business names to verify, e.g. "Ben & Jerry's Homemade, Inc.". Vermont's registry matches on a normalized form of the full registered name (short legal-suffix abbreviations like "Inc." are tolerated, but the name must otherwise match -- this is an exact lookup, not a fuzzy/partial search). Provide multiple names to batch-check several companies in one run.

## `statusFilter` (type: `string`):

Only return matches with this exact registration status. Leave blank for no filter.

## `businessTypeFilter` (type: `string`):

Only return matches of this exact registered entity type. Leave blank for no filter.

## `includeNameHistory` (type: `boolean`):

When enabled (default), fetches each matched entity's history of previous legal names and name-change filing dates, when on file.

## `includeAgentHistory` (type: `boolean`):

When enabled (default), fetches each matched entity's history of registered-agent changes, when on file.

## `includeOfficers` (type: `boolean`):

When enabled (default), includes each matched entity's on-file officers, directors, and other principals (name, title, address), when on file.

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

Maximum number of business entity records to return.

## Actor input object example

```json
{
  "businessNames": [
    "Ben & Jerry's Homemade, Inc."
  ],
  "statusFilter": "",
  "businessTypeFilter": "",
  "includeNameHistory": true,
  "includeAgentHistory": true,
  "includeOfficers": true,
  "maxItems": 5
}
```

# Actor output Schema

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

Dataset containing all scraped Vermont business entity 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 = {
    "businessNames": [
        "Ben & Jerry's Homemade, Inc."
    ],
    "includeNameHistory": true,
    "includeAgentHistory": true,
    "includeOfficers": true,
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/vermont-sos-business-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 = {
    "businessNames": ["Ben & Jerry's Homemade, Inc."],
    "includeNameHistory": True,
    "includeAgentHistory": True,
    "includeOfficers": True,
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/vermont-sos-business-search-scraper").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 '{
  "businessNames": [
    "Ben & Jerry'\''s Homemade, Inc."
  ],
  "includeNameHistory": true,
  "includeAgentHistory": true,
  "includeOfficers": true,
  "maxItems": 5
}' |
apify call crawlerbros/vermont-sos-business-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/vermont-sos-business-search-scraper"
        }
    }
}

```

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/bBKas5lsouzyULvUa/builds/775kf1uFZbZcTtASl/openapi.json