# New Business Finder — Florida, Colorado & New York Scraper (`jurassic_jove/new-business-finder`) Actor

Reach new businesses first  newly registered LLCs & corporations, days after filing. B2B leads with owner names & addresses. Florida, Colorado & New York.

- **URL**: https://apify.com/jurassic\_jove/new-business-finder.md
- **Developed by:** [Data Runner](https://apify.com/jurassic_jove) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 new business filing delivereds

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

## New Business Leads Scraper — Newly Registered LLCs & Corporations · Florida, Colorado & New York

**Find newly registered businesses and turn them into fresh B2B leads — days after they file, before anyone else.** Every week thousands of new LLCs and corporations register with the state, and a company that filed 5 days ago needs *everything*: a website, marketing, insurance, accounting, a bank, equipment, and its first customers. This scraper pulls **new business registrations straight from the official public state business registry**, normalizes each filing into a clean, time-stamped lead, and gives you the **owner/officer names, registered agent, and address** — before those businesses appear on Google Maps, Yelp, or any purchased lead list.

**Freshness is the moat.** A business registered last week has never been contacted by a competitor — this is the earliest, lowest-competition B2B lead source there is.

> ⭐ **Three states live: Florida (Sunbiz), Colorado (SOS), and New York (DOS).** The architecture is multi-state — adding a state is a drop-in module, so more are on the way. Want yours next? Ask on the **Issues** tab.

---

### ⚡ How it works (3 steps)

1. **Pick a state and a date window.** Leave dates empty for the **last 7 days** of new filings, or set your own range.
2. **Filter to your vertical.** Narrow by business-name keywords (`roofing`, `cleaning`, `consulting`…), entity type (LLC / Corporation / Nonprofit / LP-LLP), and county.
3. **Run it.** It reads the state's official public data feed, extracts every new business registration in your window, and returns clean leads with a run summary.

Under the hood it **prefers the state's official bulk public-records feed** instead of scraping the search UI — the UI can't even list filings by date — so it's fast and never blocked.

---

### 📥 Input example — roofing companies registered in the last 14 days, Tampa Bay

```json
{
  "state": "FL",
  "filedAfter": "2026-06-25",
  "filedBefore": "2026-07-09",
  "nameKeywords": ["roofing", "roof"],
  "entityTypes": ["LLC", "Corporation"],
  "counties": ["Hillsborough", "Pinellas", "Pasco"],
  "maxResults": 500,
  "enrichWithWebsite": false
}
````

Leave `nameKeywords`, `counties`, and `entityTypes` empty to pull **every** new business filing in the window.

***

### 📤 Output example

Each record is one normalized new business registration:

```json
{
  "state": "FL",
  "entityName": "SUNCOAST ROOFING & EXTERIORS LLC",
  "entityType": "LLC",
  "documentNumber": "L25000123456",
  "filedDate": "2026-07-05",
  "status": "Active",
  "principalAddress": "4820 W GANDY BLVD, STE 210",
  "city": "TAMPA",
  "county": "Hillsborough",
  "zip": "33611",
  "registeredAgentName": "MARTINEZ, CARLOS",
  "registeredAgentAddress": "4820 W GANDY BLVD, STE 210, TAMPA, FL 33611",
  "officers": [
    { "name": "MARTINEZ, CARLOS", "title": "Managing Member" },
    { "name": "MARTINEZ, ELENA", "title": "Authorized Member" }
  ],
  "registryUrl": "https://search.sunbiz.org/Inquiry/CorporationSearch/SearchResultDetail?...",
  "website": null,
  "emails": [],
  "enrichmentConfidence": null
}
```

*(Fictional record for illustration.)* Missing fields come back as `null` — never guessed. Export to CSV, Excel, JSON, or push straight into your CRM or the enrichment Actors below.

A run summary is written to the key-value store under **`OUTPUT`**: `totalFilings`, `byEntityType`, `byCounty` (top 10), `withOfficerNamesPct`, enrichment stats, the resolved `dateWindow`, and `runtimeSeconds`.

***

### 🆚 New Business Finder vs. the alternatives

| | **New Business Finder** | Buying a lead list | Manual Sunbiz search | Google Maps / directory scrapers |
|---|---|---|---|---|
| **Freshness** | Days after registration | Weeks–months old, resold | Fresh but one-at-a-time | Only businesses already established & listed |
| **Coverage** | Every new filing in the window | Whatever the vendor sampled | Whatever you type in | Only businesses with a listing |
| **Decision-maker name** | ✅ Officers + registered agent | Sometimes | ✅ (manual) | ❌ Rarely |
| **Reaches pre-website businesses** | ✅ Yes (the whole point) | ❌ | ✅ | ❌ No — needs a listing first |
| **Legal risk** | Public records, no TOS restriction | Varies / consent unclear | Public records | Site TOS / scraping gray area |
| **Cost** | ~$0.01 per fresh named lead | $$ per list, often stale | Your time | Per-listing |

***

### 👤 Who uses this scraper for lead generation

- **Marketing & web-design agencies** — every new business needs a site and a brand. Get them on day one.
- **Insurance agents & brokers** — new entities need GL, workers' comp, commercial auto, and E\&O.
- **Banks, merchant services & fintech** — open the business checking account and payment processing first.
- **Accountants, bookkeepers & payroll providers** — new entities need EIN help, books, and payroll setup.
- **B2B sellers, SaaS & equipment vendors** — sell to founders while they're still choosing vendors.
- **Commercial real estate & business services** — offices, phones, signage, legal, HR.

If your pitch is *"I help new businesses do X,"* this new-business-leads scraper is your list.

***

### 🔍 Why new-registration data beats scraped directories

- **It's the freshest lead signal that exists.** A business registration is the *first* public event in a company's life — earlier than a website, a Google listing, or a review.
- **You get a real human name.** Officers, directors/managers, and the registered agent are right in the public filing — so you address the actual decision-maker, not "To whom it may concern."
- **Zero competition at first contact.** Nobody markets to a business that isn't in any directory yet. You're first in the inbox and first in the mailbox.
- **Lowest legal risk of any lead source** (see below).

***

### ⚖️ Public records — the legal posture, stated plainly

Florida corporate, LLC, and nonprofit filings are **public government records**, created under the Florida Business Corporation Act (Ch. 607), the Florida Revised LLC Act (Ch. 605), and Ch. 617 for nonprofits, and open under **Florida's Public Records Act (Ch. 119)** and the Florida Constitution's public-records right. The state **publishes the entire registry itself** — a free public search site *and* free bulk data downloads.

There is **no license, no terms-of-service prohibition, no anti-scraping clause, and no commercial-reuse restriction** on this data — only an "as-is" accuracy disclaimer from the state. Business-registry data is **not** covered by the DPPA (that law applies only to motor-vehicle records), and no Florida exemption shields ordinary officer/registered-agent names and addresses. This Actor reads the state's **official public data feed** — the source the state built specifically for bulk access.

*How you contact the leads is regulated separately (TCPA/CAN-SPAM/Florida's telemarketing rules) — standard for any outreach, regardless of where the names came from. This is informational, not legal advice.*

***

### 🎯 Honest expectations — read this before enabling enrichment

**Most brand-new businesses do not have a website or email yet.** That's not a limitation of the scraper — it's the reality of a company that registered last week. The value of this data is **WHO** (the founders' and registered agent's names) and **WHERE** (the address), delivered while the business is brand new.

The optional **"Enrich with website & email"** toggle searches for an official site and pulls emails when one exists — but **expect a low hit rate** on fresh filings. It only bills when a plausible official site is actually found (never a Yelp/Facebook/directory page). Turn it on if you want it; just don't expect a full inbox from week-old companies.

**The right play:** use this Actor for the earliest possible contact (direct mail, phone, LinkedIn by name), then re-enrich the same list a few weeks later as those businesses build a web presence — pairing it with the enrichment Actors below.

***

### 🔗 Works perfectly with

Build a full pipeline from raw new-registration data to ready-to-send outreach:

1. **New Business Finder** *(this Actor)* — fresh filings with names & addresses.
2. **Lead Deduplicator & Merger** — dedupe across runs and merge with your existing lists.
3. **Website Email Extractor** — pull emails/socials once the businesses have sites.
4. **Email Verifier & Enricher** — validate deliverability before you send.
5. **Phone Number Validator** — clean and classify numbers for calling/SMS.
6. **Icebreaker Generator** — turn each lead into a personalized opening line.

***

### 🗺️ New business leads by state

Live now:

- **Florida** — Secretary of State / Sunbiz (official daily bulk feed). New LLCs, corporations, nonprofits, LP/LLPs, with **officers + registered agent + county**.
- **Colorado** — Secretary of State open-data (official free API). New LLCs, corporations, nonprofits, LP/LLPs, with **registered agent**. *(No officer list and no county field in Colorado's dataset.)*
- **New York** — Department of State open-data (official free API, refreshed near-daily). New LLCs, corporations, nonprofits, LP/LLPs, with **county + registered agent** (when on file). *(No officer list in New York's dataset.)*

The engine is built on a state-agnostic registry adapter, so **new states drop in as modules**. Want *new business leads* for **Texas, California, Georgia, Washington**, or anywhere else? Request it on the **Issues** tab and it moves up the queue. *(Coverage depends on what each state publishes — states with a free bulk feed or open-data API, like FL/CO/NY, are added fastest; states that only offer a search UI take longer.)*

***

### 💵 Pricing (pay-per-event)

You pay only for results, not for run time:

| Event | When it fires | Price |
|---|---|---|
| **Business found** | Each normalized new filing delivered to your dataset (passed your filters, inside your window) | **$0.01** |
| **Business enriched** | Only when website enrichment runs — a plausible official site was found and scraped | **$0.02** |
| Actor start | Synthetic start event (Apify waives the first 5 seconds of compute) | $0.00005 |

- Public-records data is cheap to serve, so **`business-found` is priced for volume** — 1,000 fresh, named leads for **$10**.
- **Filtered-out and failed records are never charged.** Enrichment is charged only when a site is actually found — not for every attempt.
- Set a **maximum results** cap (default 200, hard max 2,000) and an event charge limit to control spend.

***

### ⚠️ Limitations

- **Florida, Colorado & New York are live; more states coming.** The code is built around a `RegistryAdapter` interface — new states are drop-in modules. **Request a state on the Issues tab.**
- **Coverage varies by each state's public data.** Florida (bulk feed) has officers + registered agent + ZIP-derived county (all 67 counties). New York (open-data) has county + registered agent, no officers. Colorado (open-data) has the registered agent, no officers, no county. County filtering therefore works for Florida & New York; a filing whose county can't be determined is excluded when a county filter is set (and counted in the summary, never hidden).
- **New businesses rarely have websites/emails yet** — see *Honest expectations*.
- Data is only as complete as the public filing. Some new filings omit officers or list only a registered agent; those fields come back `null`.

***

### ❓ FAQ

#### How do I find newly registered businesses in Florida?

Run this Actor with `state: "FL"` and a date window (or leave it empty for the last 7 days). It reads Florida's official Sunbiz public data feed and returns every new LLC, corporation, nonprofit, and LP/LLP registered in that window, with owner/officer names and addresses.

#### How do I find newly registered businesses in New York?

Set `state: "NY"`. It reads the New York Department of State's official open-data feed (refreshed near-daily) and returns new LLC and corporation filings in your window — with entity type, county, and registered agent.

#### How do I find newly registered businesses in Colorado?

Set `state: "CO"`. It reads the Colorado Secretary of State's official open-data feed and returns new LLC, corporation, nonprofit, and LP/LLP filings in your window, with the registered agent and address.

#### How fresh is the data?

It comes from the state's daily-updated public feed. You typically see filings within a day or two of the state entering them — days before those businesses appear anywhere else.

#### Is scraping business-registry data legal?

Yes. These are public government records the state publishes for exactly this kind of access — there's no terms-of-service or licensing restriction on the data. See *Public records* above. (How you *contact* leads is governed by the usual TCPA/CAN-SPAM rules, like any outreach.)

#### Why don't most records have an email address?

Because the business is brand new and hasn't built a website yet. This scraper's edge is being early — with real names and addresses. Enrich later as the businesses mature.

#### Can I target a specific industry?

Yes — use `nameKeywords` (e.g. `roofing`, `hvac`, `cleaning`, `trucking`, `consulting`). It matches the business name, which is how new companies signal their industry.

#### Can I filter by city or county?

Filter by `counties` (e.g. `Hillsborough`, `Miami-Dade`). City is included in every record for finer sorting.

#### What entity types are included?

LLCs, for-profit corporations, nonprofits, and LPs/LLPs — filter to any subset.

#### How do I control cost?

Set `maxResults` and, in the Console, an event charge limit. You're billed per delivered record; filtered-out records cost nothing.

#### How much does a new business leads list cost?

Bought lists run into the hundreds of dollars and are often weeks stale. Here you pay **$0.01 per fresh, named lead** — 1,000 newly registered businesses for **$10** — and only for records that pass your filters. Florida logs **hundreds of new business filings every business day** (well over 300,000 new entities a year), so a single run can surface a large, current list.

#### What's the best way to reach a business right after it registers?

For a week-old business, direct mail and phone beat email (most have no website/email yet). Address the **named officer or registered agent** from the filing, reference that they *just* registered, and lead with the one thing a brand-new business needs from you. Re-touch by email a few weeks later once they're online — see *Works perfectly with* for the enrichment pipeline.

#### Which states are coming next?

It's demand-driven — tell us on the Issues tab which state you want and it moves up the list.

***

### How to build a new-business outreach list (workflow)

1. Run **New Business Finder** for your state, date window, and industry keywords → fresh filings with names + addresses.
2. Deduplicate against your CRM with **Lead Deduplicator & Merger**.
3. A few weeks later, run **Website Email Extractor** + **Email Verifier** over the same list to add and validate emails as the businesses come online.
4. Validate phones with **Phone Number Validator**, then generate personalized openers with **Icebreaker Generator**.
5. Reach out by mail/phone/LinkedIn *first* (day-one advantage), then email once verified.

***

### Input reference

| Field | Type | Default | Description |
|---|---|---|---|
| `state` | select | `FL` | State registry: `FL` (Florida/Sunbiz), `CO` (Colorado SOS), or `NY` (New York DOS). More coming. |
| `filedAfter` | date | 7 days ago | Include businesses registered on/after this date (inclusive). |
| `filedBefore` | date | today | Include businesses registered on/before this date (inclusive). |
| `entityTypes` | multi-select | all | LLC, Corporation, Nonprofit, LP/LLP. |
| `nameKeywords` | string list | — | Keep names containing ANY keyword (case-insensitive). |
| `counties` | string list | — | Keep principal-address county matching ANY value. |
| `maxResults` | integer | 200 | Cap on delivered filings (hard max 2,000). |
| `enrichWithWebsite` | boolean | `false` | Best-effort website + email lookup (expect a low hit rate). |
| `proxyConfiguration` | proxy | Apify Proxy | Proxy for enrichment (residential US recommended). |

***

Built by **Data Runner** — a portfolio of lead-generation and data-enrichment Actors with a >99% run success rate.

# Actor input Schema

## `state` (type: `string`):

State business registry to search. Supports Florida (Sunbiz), Colorado (Secretary of State), and New York (Department of State) — more states are coming; request one on the Actor's Issues tab.

## `filedAfter` (type: `string`):

Only include businesses registered ON or AFTER this date (registry local time). Format YYYY-MM-DD. Leave EMPTY to default to 7 days ago.

## `filedBefore` (type: `string`):

Only include businesses registered ON or BEFORE this date (registry local time). Format YYYY-MM-DD. Leave EMPTY to default to today.

## `entityTypes` (type: `array`):

Which entity types to include. Leave all selected (default) to include every type.

## `nameKeywords` (type: `array`):

Only include businesses whose name contains ANY of these keywords (case-insensitive). This is how agencies target a vertical — e.g. "roofing", "cleaning", "consulting", "trucking". Leave empty for no name filter.

## `counties` (type: `array`):

Only include businesses whose principal-address county matches ANY of these (case-insensitive). Florida county names, e.g. "Hillsborough", "Miami-Dade", "Orange". Leave empty for statewide.

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

Maximum number of business filings to return (after filters). Hard cap 2000.

## `enrichWithWebsite` (type: `boolean`):

Attempt to find an official website + email for each business. IMPORTANT: brand-new businesses usually have NO website yet — expect a LOW hit rate. The core value of this Actor is WHO (officers) and WHERE (address), not email volume. Enrichment is charged only when a plausible official site is actually found and scraped.

## `proxyConfiguration` (type: `object`):

Apify proxy used for registry requests and website enrichment. Residential US proxy is recommended. Defaults to Apify Proxy automatic.

## `acquisitionMode` (type: `string`):

How to acquire filings. "auto" (recommended) prefers the official bulk public-records data file and falls back to the search UI. "bulk" forces the bulk file; "ui" forces the search-UI scraper.

## `bulkDataUrl` (type: `string`):

Optional override pointing at a specific Sunbiz Corporate Data File (daily/quarterly). Accepts an https URL or a local file path (used for testing). Leave empty to let the Actor discover the latest official file automatically.

## `healthCheck` (type: `boolean`):

MAINTAINER USE — leave OFF for normal lead scraping. When enabled, the run ignores every other input and instead probes each open-data source (Colorado, New York): it fetches the single most-recent record and verifies the critical fields the parser depends on still exist. The run FAILS loudly if a source is unreachable or a field is missing — pair with a daily Apify schedule + failed-run notification to get alerted the moment an open-data schema changes and a parser needs updating. Charges nothing.

## Actor input object example

```json
{
  "state": "FL",
  "entityTypes": [
    "LLC",
    "Corporation",
    "Nonprofit",
    "LP_LLP"
  ],
  "nameKeywords": [],
  "counties": [],
  "maxResults": 200,
  "enrichWithWebsite": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "acquisitionMode": "auto",
  "healthCheck": false
}
```

# 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 = {
    "state": "FL",
    "entityTypes": [
        "LLC",
        "Corporation",
        "Nonprofit",
        "LP_LLP"
    ],
    "nameKeywords": [],
    "counties": [],
    "maxResults": 200,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    },
    "acquisitionMode": "auto",
    "bulkDataUrl": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("jurassic_jove/new-business-finder").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 = {
    "state": "FL",
    "entityTypes": [
        "LLC",
        "Corporation",
        "Nonprofit",
        "LP_LLP",
    ],
    "nameKeywords": [],
    "counties": [],
    "maxResults": 200,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
    "acquisitionMode": "auto",
    "bulkDataUrl": "",
}

# Run the Actor and wait for it to finish
run = client.actor("jurassic_jove/new-business-finder").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 '{
  "state": "FL",
  "entityTypes": [
    "LLC",
    "Corporation",
    "Nonprofit",
    "LP_LLP"
  ],
  "nameKeywords": [],
  "counties": [],
  "maxResults": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "acquisitionMode": "auto",
  "bulkDataUrl": ""
}' |
apify call jurassic_jove/new-business-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=jurassic_jove/new-business-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "New Business Finder — Florida, Colorado & New York Scraper",
        "description": "Reach new businesses first  newly registered LLCs & corporations, days after filing. B2B leads with owner names & addresses. Florida, Colorado & New York.",
        "version": "0.1",
        "x-build-id": "mKEe1Y2OiQwACWQNp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jurassic_jove~new-business-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jurassic_jove-new-business-finder",
                "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/jurassic_jove~new-business-finder/runs": {
            "post": {
                "operationId": "runs-sync-jurassic_jove-new-business-finder",
                "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/jurassic_jove~new-business-finder/run-sync": {
            "post": {
                "operationId": "run-sync-jurassic_jove-new-business-finder",
                "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",
                "properties": {
                    "state": {
                        "title": "State",
                        "enum": [
                            "FL",
                            "CO",
                            "NY"
                        ],
                        "type": "string",
                        "description": "State business registry to search. Supports Florida (Sunbiz), Colorado (Secretary of State), and New York (Department of State) — more states are coming; request one on the Actor's Issues tab.",
                        "default": "FL"
                    },
                    "filedAfter": {
                        "title": "Filed after (inclusive)",
                        "type": "string",
                        "description": "Only include businesses registered ON or AFTER this date (registry local time). Format YYYY-MM-DD. Leave EMPTY to default to 7 days ago."
                    },
                    "filedBefore": {
                        "title": "Filed before (inclusive)",
                        "type": "string",
                        "description": "Only include businesses registered ON or BEFORE this date (registry local time). Format YYYY-MM-DD. Leave EMPTY to default to today."
                    },
                    "entityTypes": {
                        "title": "Entity types",
                        "type": "array",
                        "description": "Which entity types to include. Leave all selected (default) to include every type.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "LLC",
                                "Corporation",
                                "Nonprofit",
                                "LP_LLP"
                            ],
                            "enumTitles": [
                                "LLC",
                                "Corporation (Inc.)",
                                "Nonprofit",
                                "LP / LLP"
                            ]
                        },
                        "default": [
                            "LLC",
                            "Corporation",
                            "Nonprofit",
                            "LP_LLP"
                        ]
                    },
                    "nameKeywords": {
                        "title": "Business-name keywords",
                        "type": "array",
                        "description": "Only include businesses whose name contains ANY of these keywords (case-insensitive). This is how agencies target a vertical — e.g. \"roofing\", \"cleaning\", \"consulting\", \"trucking\". Leave empty for no name filter.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "counties": {
                        "title": "Counties",
                        "type": "array",
                        "description": "Only include businesses whose principal-address county matches ANY of these (case-insensitive). Florida county names, e.g. \"Hillsborough\", \"Miami-Dade\", \"Orange\". Leave empty for statewide.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of business filings to return (after filters). Hard cap 2000.",
                        "default": 200
                    },
                    "enrichWithWebsite": {
                        "title": "Enrich with website & email (best effort)",
                        "type": "boolean",
                        "description": "Attempt to find an official website + email for each business. IMPORTANT: brand-new businesses usually have NO website yet — expect a LOW hit rate. The core value of this Actor is WHO (officers) and WHERE (address), not email volume. Enrichment is charged only when a plausible official site is actually found and scraped.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy used for registry requests and website enrichment. Residential US proxy is recommended. Defaults to Apify Proxy automatic.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "acquisitionMode": {
                        "title": "Data acquisition mode (advanced)",
                        "enum": [
                            "auto",
                            "bulk",
                            "ui"
                        ],
                        "type": "string",
                        "description": "How to acquire filings. \"auto\" (recommended) prefers the official bulk public-records data file and falls back to the search UI. \"bulk\" forces the bulk file; \"ui\" forces the search-UI scraper.",
                        "default": "auto"
                    },
                    "bulkDataUrl": {
                        "title": "Bulk data file URL / path (advanced)",
                        "type": "string",
                        "description": "Optional override pointing at a specific Sunbiz Corporate Data File (daily/quarterly). Accepts an https URL or a local file path (used for testing). Leave empty to let the Actor discover the latest official file automatically."
                    },
                    "healthCheck": {
                        "title": "Data-source health check (maintainer)",
                        "type": "boolean",
                        "description": "MAINTAINER USE — leave OFF for normal lead scraping. When enabled, the run ignores every other input and instead probes each open-data source (Colorado, New York): it fetches the single most-recent record and verifies the critical fields the parser depends on still exist. The run FAILS loudly if a source is unreachable or a field is missing — pair with a daily Apify schedule + failed-run notification to get alerted the moment an open-data schema changes and a parser needs updating. Charges nothing.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
