# New Business Filings Scraper (`usta/new-business-filings-scraper`) Actor

New business filings from the public city business registries of California (Los Angeles, San Francisco), Illinois (Chicago) and New York (New York City). One row per filing, each with the registry record link. No rows are invented; a silent registry returns UNKNOWN.

- **URL**: https://apify.com/usta/new-business-filings-scraper.md
- **Developed by:** [US Tech Automations](https://apify.com/usta) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 result rows

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Fresh New-Business Leads From City Registries

Insurance agents and payroll or accounting sales reps get freshly filed local business registrations from LA, San Francisco, Chicago and New York City, already filtered to new filings only.

### Introduction

Pick a state, pick how many days back you want to look, and get every new business
filing the covered public registry published in that window. One row per filing.
Every row carries a link straight back to the registry record it came from, so any
row can be checked at its source.

Three states are covered today, and only because each one has a public registry
that answers:

| State | Registry read | What a filing is there |
|---|---|---|
| CA | City of Los Angeles business tax registry, and San Francisco registered business locations | A business start date on the LA tax registry, or a trading name start date in San Francisco |
| IL | City of Chicago business licences | A licence the city marks as a new issue, never a renewal |
| NY | New York City Department of Consumer and Worker Protection licences | The date the licence record was created |

These are city business registries. They are not Secretary of State corporate
formation filings, and a business that registered with a state but not with one of
these cities will not appear. Read the Limitations section before paying.

The intended use is lead research, onboarding and market tracking: finding the
businesses that entered a registry recently, with an address and a trade
description attached, rather than looking a known company up by name.

### Tutorial

1. Set `state` to CA, IL or NY.
2. Set `daysBack` to a whole number from 1 to 30. It counts back from today,
   inclusive, so `1` means today only.
3. Set `maxItems` to cap the run. It defaults to 200, so a run left on that
   default costs at most $0.60.
4. Start the run. Rows land in the default dataset and can be exported as JSON,
   CSV or Excel. The run's OUTPUT record holds the status, the row count and the
   list of registries actually read.

A run ends in exactly one of three states. `OK` means the registry answered, and
the rows are there (possibly zero, if nothing was filed in that window).
`INVALID_INPUT` means the request was outside the supported inputs, and nothing was
pushed. `UNKNOWN` means a registry did not answer, and nothing was pushed. A row is
never invented to fill a gap.

### Pricing

**$0.003 per row.** Each row written to the dataset is one charged event, from
the first row.

`maxItems` defaults to 200, so a run left on its defaults costs at most $0.60. At
this price 1,000 rows costs $3.00.

There is no start fee. A run that finds no filings, hits a bad input, or cannot
reach the registry pushes no rows, and so costs nothing.

### Input and output examples

Input:

```json
{
  "state": "IL",
  "daysBack": 7,
  "maxItems": 200
}
```

One real output row:

```json
{
  "state": "IL",
  "jurisdiction": "Chicago, IL",
  "registry": "data.cityofchicago.org/r5kz-chrr",
  "filing_id": "3100413",
  "filing_date": "2026-09-09",
  "filing_date_means": "Date the city issued the licence",
  "business_name": "REDLINE TOWING, INC.",
  "trade_name": "REDLINE TOWING",
  "address": "10103  KITTY AVE",
  "city": "CHICAGO RIDGE",
  "zip": "60415",
  "naics_code": null,
  "naics_description": null,
  "business_activity": "Operation of a Tow Truck",
  "record_status": "AAI",
  "latitude": null,
  "longitude": null,
  "source_url": "https://data.cityofchicago.org/resource/r5kz-chrr.json?license_id=3100413",
  "fetched_at": "2026-09-15T02:27:46Z"
}
```

Every field, in every row:

| Field | What it holds |
|---|---|
| `state` | The two-letter state you asked for |
| `jurisdiction` | The city whose registry the row came from |
| `registry` | The host and dataset id of that registry |
| `filing_id` | The registry's own id for this record |
| `filing_date` | The date on the registry record, `YYYY-MM-DD` |
| `filing_date_means` | What that date means in this registry, in words |
| `business_name` | The legal or ownership name on the record |
| `trade_name` | The doing-business-as name, where the registry has one |
| `address` | Street address on the record |
| `city` | City on the record |
| `zip` | Postal code exactly as the registry publishes it |
| `naics_code` | Industry code, where the registry has one |
| `naics_description` | Industry description, where the registry has one |
| `business_activity` | Free-text trade description, where the registry has one |
| `record_status` | The registry's own status code, where it has one |
| `latitude`, `longitude` | Coordinates, where the registry has them |
| `source_url` | Public link that returns this exact record |
| `fetched_at` | UTC timestamp of the run, ISO format |

A field is `null` when that registry does not publish it. It is never filled in
from somewhere else.

### Limitations

Read this before paying.

- **Three states, four cities.** CA means Los Angeles and San Francisco only. IL
  means Chicago only. NY means New York City only. Nothing outside those four city
  registries is read.
- **City registries, not the Secretary of State.** A company that formed at state
  level and never registered with one of these cities is absent.
- **New York runs about four weeks behind.** On 14 September 2026 the newest NYC
  record was dated 19 August 2026. A `daysBack` of 7 returns nothing for NY. Use 30.
- **The four registries date a filing differently.** That is why `filing_date_means`
  travels with every row instead of all four being labelled "filed".
- **Contact details are not included.** These registries publish a business name and
  address. There is no email column and no phone column in three of the four, so
  this is not a mailing list and is not sold as one.
- **Coverage is all-or-nothing per state.** California is read from two registries.
  If either one is down, the whole state returns UNKNOWN rather than handing over
  half of California as though it were all of it.
- **Freshness follows the registry.** Chicago, San Francisco and Los Angeles are
  current to roughly the previous day. None of that is under this actor's control.

### Recommendations

- Run it daily with `daysBack` set to 2 or 3. The small overlap covers a registry
  that published late, and duplicate filings inside one run are removed anyway.
- For NY, run weekly with `daysBack` of 30.
- Use `filing_id` together with `jurisdiction` as the unique key when loading rows
  into your own store across runs.
- Keep `maxItems` at 200 while testing so a test run stays under $0.60, then raise
  it once the output looks right.
- Follow `source_url` before acting on any single row. It returns that record from
  the registry itself.

### FAQ

**Is this Secretary of State data?** No. It is city business registry data from Los
Angeles, San Francisco, Chicago and New York City. The Limitations section says
exactly what that excludes.

**Why did a run return zero rows?** Either nothing was filed in that window, or the
window is too short for a registry that lags. NY is the usual answer. A zero-row run
costs nothing.

**What happens if a registry is down?** The run reports `UNKNOWN` with the error and
pushes no rows. No row is ever guessed at, and no charge is made.

**Can the same filing be charged twice in one run?** No. Rows are de-duplicated on
the registry's own record id before anything is pushed.

**Are more states coming?** Unknown. Only registries that have been checked against
a live response are listed, and nothing is added on the basis of a plan.

**Is there email or phone data?** No. See Limitations.

**How do I cap what a run costs?** Set `maxItems`. It is a hard cap on rows, and
rows are the only thing charged for.

### Refunds and support

Refunds: if a run returns zero rows for a valid input, email operations@ustechautomations.com within 7 days and we refund that run. Support: same address, replies within 2 business days.

# Actor input Schema

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

The state to read. Only states with a covered public registry are listed: CA (Los Angeles and San Francisco), IL (Chicago), NY (New York City).

## `daysBack` (type: `integer`):

How many days of filings to read, counting back from today (1-30). New York City's registry runs about four weeks behind, so use 30 for NY.

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

Hard cap on rows for this run, so your spend is capped too. Each row is one charged event. Every row bills at the listed price from row one; there is no start fee.

## Actor input object example

```json
{
  "state": "CA",
  "daysBack": 7,
  "maxItems": 200
}
```

# Actor output Schema

## `filings` (type: `string`):

No description

## `report` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "state": "CA",
    "daysBack": 7,
    "maxItems": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("usta/new-business-filings-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 = {
    "state": "CA",
    "daysBack": 7,
    "maxItems": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("usta/new-business-filings-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 '{
  "state": "CA",
  "daysBack": 7,
  "maxItems": 200
}' |
apify call usta/new-business-filings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,usta/new-business-filings-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/5LGEANDdha9c0wiM2/builds/vTDuqE1PCdPnsJYcG/openapi.json