DEV Community

Your Evenings Data
Your Evenings Data

Posted on

Check a US company's good standing from Secretary of State open data (Python, no API key)

Article type: How-to guide (one task: check whether a NY, CO, OR or CT entity is in good standing)

Prerequisites: Python 3 with requests. No API key is needed for the state open-data APIs. An Apify account and API token only if you use the shortcut at the end.

Tested on: 14 November 2026

If you need a quick "does this company exist, and is it in good standing?" check, for example as one step in a KYB or vendor-onboarding flow, four states make it easy: New York, Colorado, Oregon and Connecticut publish their Secretary of State business registers as open datasets with a free JSON API. One GET request with the state's entity ID returns the record. Colorado and Connecticut include the entity's status, so you can read good standing from it. New York and Oregon publish active entities only, so a listed entity is active. You don't need an API key or an account.

This post shows the four endpoints, a short Python good-standing check, the status values you'll meet, and a name search. A hosted version comes at the end.

Which states have a Secretary of State API you can call without a key?

All four run on the Socrata open-data platform, so they share one query language (SoQL) and one URL shape: https://<portal>/resource/<dataset-id>.json.

State Dataset Entity ID column What it covers
New York data.ny.gov/resource/n9v6-gdp6.json (Active Corporations) dos_id Active entities only
Colorado data.colorado.gov/resource/4ykn-tg5h.json (Business Entities in Colorado) entityid All statuses, in entitystatus
Oregon data.oregon.gov/resource/tckn-sxa6.json (Active Businesses - ALL) registry_number Active entities only
Connecticut data.ct.gov/resource/n7gp-d28j.json (Business Registry - Business Master) accountnumber All statuses, in status and sub_status

How do I look up one entity by ID?

Filter on the ID column with $where. curl -G with --data-urlencode handles the escaping:

curl -sG https://data.colorado.gov/resource/4ykn-tg5h.json \
  --data-urlencode "\$where=entityid='18961000001'" \
  --data-urlencode '$select=entityid,entityname,entitystatus,entitytype,entityformdate'
Enter fullscreen mode Exit fullscreen mode
[{"entityid":"18961000001","entityname":"PARK RESERVOIR COMPANY","entitystatus":"Good Standing","entitytype":"DPC","entityformdate":"1896-03-16T00:00:00.000"}]
Enter fullscreen mode Exit fullscreen mode

How do I check good standing in Python?

The same lookup for all four states, plus a status rule. pip install requests, then:

import re
import requests

# One open dataset per state, and the column that holds the state's entity ID.
SOURCES = {
    "NY": ("https://data.ny.gov/resource/n9v6-gdp6.json", "dos_id", "current_entity_name"),
    "CO": ("https://data.colorado.gov/resource/4ykn-tg5h.json", "entityid", "entityname"),
    "OR": ("https://data.oregon.gov/resource/tckn-sxa6.json", "registry_number", "business_name"),
    "CT": ("https://data.ct.gov/resource/n7gp-d28j.json", "accountnumber", "name"),
}

CO_ACTIVE = {"Good Standing", "Exists"}
CO_NOT_GOOD = {"Delinquent", "Noncompliant", "Registered Agent Resigned"}
CT_ACTIVE = {"Active", "Active - Pending Domestication", "Recorded", "Registered", "Redomesticated"}
CT_NOT_GOOD_SUB = re.compile(r"dissolution|forfeiture|revocation|no agent", re.I)


def fetch(state, entity_id):
    url, id_col, _ = SOURCES[state]
    if not entity_id.isdigit():
        raise ValueError("state entity IDs here are digits only")
    r = requests.get(url, params={"$where": f"{id_col}='{entity_id}'", "$limit": 10}, timeout=30)
    r.raise_for_status()
    return r.json()


def standing(state, entity_id):
    rows = fetch(state, entity_id)
    if not rows:
        # NY and OR publish active entities only, so "not listed" can mean
        # inactive or a wrong ID. Check the state's search page before acting on it.
        return {"state": state, "id": entity_id, "status": "not_listed"}
    row = rows[0]  # Oregon returns one row per address/agent type; the name is the same
    name = row[SOURCES[state][2]]
    if state in ("NY", "OR"):
        return {"state": state, "id": entity_id, "name": name,
                "status": "active", "detail": "listed in the active dataset"}
    if state == "CO":
        s = row.get("entitystatus")
        status = ("active" if s in CO_ACTIVE else
                  "not_in_good_standing" if s in CO_NOT_GOOD else "inactive")
        return {"state": state, "id": entity_id, "name": name, "status": status, "detail": s}
    s, sub = row.get("status"), row.get("sub_status")
    if s in CT_ACTIVE:
        status = "not_in_good_standing" if sub and CT_NOT_GOOD_SUB.search(sub) else "active"
    elif s and (s.startswith("Pending") or s == "Domesticated"):
        status = "unknown"
    else:
        status = "inactive"
    return {"state": state, "id": entity_id, "name": name, "status": status,
            "detail": " - ".join(x for x in (s, sub) if x)}


if __name__ == "__main__":
    for state, entity_id in [("NY", "4424185"), ("CO", "18961000001"),
                             ("OR", "338616"), ("CT", "0067276"), ("NY", "1")]:
        print(standing(state, entity_id))
Enter fullscreen mode Exit fullscreen mode

Output on 14 November 2026:

{'state': 'NY', 'id': '4424185', 'name': "BUTCHY'S WINE & SPIRITS, INC.", 'status': 'active', 'detail': 'listed in the active dataset'}
{'state': 'CO', 'id': '18961000001', 'name': 'PARK RESERVOIR COMPANY', 'status': 'active', 'detail': 'Good Standing'}
{'state': 'OR', 'id': '338616', 'name': 'PORTLAND TERMINAL RAILROAD COMPANY', 'status': 'active', 'detail': 'listed in the active dataset'}
{'state': 'CT', 'id': '0067276', 'name': 'TORRINGTON LIBRARY', 'status': 'active', 'detail': 'Active'}
{'state': 'NY', 'id': '1', 'status': 'not_listed'}
Enter fullscreen mode Exit fullscreen mode

The status rule is a starting point. The function returns the state's own wording in detail, so you can make it stricter for your use case.

What do the Colorado and Connecticut status values mean?

Colorado puts one value in entitystatus. Counts across the whole dataset on 14 November 2026:

entitystatus Records
Delinquent 1,162,812
Good Standing 1,031,927
Voluntarily Dissolved 604,581
Administratively Dissolved 157,830
Withdrawn 80,868
Noncompliant 30,150
Revoked 20,686
Judicially Dissolved 15,925
Exists 15,656

Smaller groups: Merged, Converted, Registered Agent Resigned, Effectiveness Prevented, Dissolved (Term Expired) and Consolidated. There are more Delinquent records than Good Standing ones, so "it's in the Colorado register" tells you very little on its own. Read the status.

Connecticut splits it in two. status says Active, Dissolved, Forfeited and so on, and sub_status adds a flag on some Active records. Of the Active records on 14 November 2026, 173,444 had no sub-status, and the most common flags were:

sub_status (on Active records) Records
Annual report due 212,244
Annual report past due 52,204
Admin Dissolution Initiated 18,910
Ready for Forfeiture 2,341
First report past due 1,357
Ready for dissolution 913

So "Active" isn't the whole story in Connecticut. The rule above treats a dissolution, forfeiture or revocation flag (or No Agent) as not in good standing and leaves report reminders as active. If an overdue annual report matters to you, check detail for it.

Four gotchas from the raw data

  1. Colorado names can carry a status note. 1,000,245 Colorado records have a name containing ", Delinquent ", such as EXAMPLE LLC, Delinquent April 1, 2020. Match on entityid, and strip the note if you show the name.
  2. Oregon returns several rows per entity, one per associated_name_type (registered agent, principal place of business, mailing address). Deduplicate on registry_number.
  3. Connecticut uses a placeholder date. 18,687 records have date_registration set to 0001-01-01. Treat it as unknown.
  4. "Not listed" is ambiguous in New York and Oregon. Those datasets hold active entities only, so a missing ID can mean inactive or a typo. Confirm on the state's own business search before acting on it.

How do I search by name (Colorado business search, Connecticut business search)?

Use SoQL's starts_with on the name column. It's case-sensitive and Colorado names come in mixed case, so compare upper-cased name and prefix:

import requests

def search_co(prefix, limit=5):
    prefix = prefix.upper().replace("'", "''")   # match case-insensitively; SoQL escapes a quote by doubling it
    r = requests.get(
        "https://data.colorado.gov/resource/4ykn-tg5h.json",
        params={
            "$select": "entityid,entityname,entitystatus,entityformdate",
            "$where": f"starts_with(upper(entityname), '{prefix}')",
            "$order": "entityname",
            "$limit": limit,
        },
        timeout=30,
    )
    r.raise_for_status()
    return r.json()

for row in search_co("Park Reservoir"):
    print(row["entityid"], row["entityname"], row["entitystatus"], row["entityformdate"][:10])
Enter fullscreen mode Exit fullscreen mode
18961000001 PARK RESERVOIR COMPANY Good Standing 1896-03-16
Enter fullscreen mode Exit fullscreen mode

Swap in the URL and columns from the table above for New York, Oregon (Oregon business search) or Connecticut (Connecticut business search). The function doubles any single quote in the input, which is how SoQL escapes it, so a name like O'Brien doesn't break the query.

Rate limits

You don't need a token, but Socrata throttles requests without one by IP address. If you're checking more than a handful of entities, register a free app token on the portal and send it in the X-App-Token header. Socrata says it doesn't currently throttle requests that use an app token, unless they're abusive.

These datasets are copies the states publish on their own schedule: on 14 November 2026 the Oregon dataset had last been updated on 10 November, the Colorado dataset on 13 November, and the New York and Connecticut datasets that day. For a formal certificate of good standing, order one from the Secretary of State.

The shortcut (Disclosure: we built this)

We built an Apify Actor, Secretary of State Business Entity Search, that runs the lookup above for New York, Colorado, Oregon and Connecticut and returns one schema for all four. Each row has status (active, not_in_good_standing, inactive or unknown), the state's own wording in statusDetail, plus formationDate, entityType, jurisdictionOfFormation, recordUrl (the state's business search) and sourceUrl (the record in the open dataset). Besides ID lookup, it can search by name and list new filings, and a monitor mode reports new and changed entities on later runs.

curl -s -X POST "https://api.apify.com/v2/acts/yourevenings~us-state-business-entities/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"mode":"lookup","entities":["NY:4424185","CO:18961000001","OR:338616","CT:0067276"]}'
Enter fullscreen mode Exit fullscreen mode

In our test run on 1 November 2026 it returned the same four entities, all active (the Python check above gave the same result on 14 November). It's pay per event: a base price of $0.0025 per entity record, plus a $0.00005 Actor-start fee per run per GB of memory. Monitor mode adds $0.01 per run that returns new or changed entities, and status rows (such as an ID that isn't found) are free. The four-row run above comes to $0.01 plus the start fee. The Python above is all you need if you'd rather run it yourself.

Secretary of State Business Entity Search on Apify

Your Evenings

Top comments (0)