12.4 Million US Business Registrations Are Free on State Open-Data Portals

If you've ever needed US company registration data — who registered what LLC, when, where — you've probably hit the same walls we did. OpenCorporates has great coverage, but the free tier is heavily capped and commercial use requires a license that starts in "contact sales" territory. Aggregator sites like secstates.com are mostly portals that link back to each state's search page — no bulk data. And Delaware, where a huge share of US companies actually incorporate, offers zero bulk access and zero API. Selling that data is part of the state's business model.

So we assumed this data was simply locked up. It isn't. Several states publish their entire business registry — every LLC, corporation, and nonprofit ever registered — as open data on Socrata portals, explicitly in the public domain or licensed for commercial use. Here's what we verified, what we built to pull it, and the rate-limit realities we measured along the way.

Which states just give you everything?

Each of these is a Socrata SODA endpoint. All record counts below are from live count(*) queries against the datasets; all license terms were verified on the dataset pages (June 2026).

Total: roughly 12.4 million business entities, with names, entity types, formation dates, addresses, and (in most states) registered agents. New York deserves a special mention: the active-corporations file goes back to 1800, and a companion dataset (63wc-4exh) holds 20.6 million raw filing records if you want full filing history rather than current state.

One script, config-driven

Every state names its columns differently (entityname vs business_name vs current_entity_name), so our fetcher is a single Python-stdlib script driven by a SOURCES dict — one entry per state, mapping onto a normalized schema. Adding a new Socrata state is one more dict entry:

"co": {
    "name": "Colorado",
    "resource": "https://data.colorado.gov/resource/4ykn-tg5h.json",
    "license": "Public Domain",
    "fields": {
        "entity_id":      "entityid",
        "name":           "entityname",
        "entity_type":    "entitytype",
        "status":         "entitystatus",
        "formation_date": "entityformdate",
        "city":           "principalcity",
        "region":         "principalstate",
        "postal":         "principalzipcode",
        "agent_org":      "agentorganizationname",
        "agent_first":    "agentfirstname",
        "agent_last":     "agentlastname",
    },
},

Output is one JSONL file per state with a unified schema (state / entity_id / name / entity_type / status / formation_date / city / region / postal / agent_name), plus the raw row preserved under _raw so nothing is lost in normalization. Pagination is $limit/$offset ordered by :id, with resume-by-line-count: if the pull dies at row 650,000, rerunning counts the lines already on disk and continues from that offset in append mode. Each page is flushed before moving on, so the file is always a valid resume point.

How fast can you actually pull Socrata data?

This is where we burned the most time, so here are actual measurements from anonymous (no app token) requests in June 2026.

• Plain offset pagination: ~500 rows/sec. This is the best you'll do anonymously. Counter-intuitively, deep offsets are not the problem — a query at offset 1,000,000 returns in about 3 seconds, barely slower than offset 0. The bottleneck is per-page transfer throughput, not offset depth. The classic "keyset beats offset" instinct is wrong here.
• Keyset pagination via $select=:*,* is a dead end. The standard Socrata advice for large extracts is to paginate on system fields (:id). In practice, asking for :* forces the server to compute system metadata for every row, and a single 50k-row page took 200+ seconds and then timed out.
• The CSV bulk export endpoint is even slower. /api/views/{id}/rows.csv looks like a bulk-download shortcut. It isn't — the file is generated server-side on demand, and we measured 1,229 rows in 30 seconds. That's 40 rows/sec, roughly 12× slower than JSON offset paging.

At ~500 rows/sec, the full ~13M rows across these states is a 7–8 hour pull. Register a free Socrata app token and send it as X-App-Token for a higher rate-limit tier — worth doing for the full pull; the anonymous numbers above are the floor.

Gotchas that will silently corrupt your data

• Row granularity differs per state. Oregon's dataset is one row per associated name, and Pennsylvania's is one row per officer — multiple rows share one entity ID. Naively counting rows overcounts entities by 2–3×. Dedup on registry_number / filing_number is mandatory.
• CSV column labels ≠ API field names. Connecticut's CSV export has Title_Case labels like Business_City, while the SODA API uses billingcity. If you mix export formats, map columns through the dataset metadata (/api/views/{id}.json → columns[].fieldName), never by header string.
• Connecticut splits agents into companion datasets. The master table (n7gp-d28j) has no agent columns; registered agents and principals live in separate Agent Details / Principal Details datasets joined on accountnumber.

Which states can't you get, and why?

• California, Texas, Delaware: bulk registry data is paid. Delaware in particular has no bulk product and no API at any price we could find — remarkable, given it's the incorporation capital of the country.
• Florida: free! But it's a fixed-width flat file on an FTP server (Sunbiz), so it needs its own parser rather than the Socrata adapter.
• Ohio: publishes monthly bulk files, but the SoS site sits behind an aggressive bot wall; you need a real browser session to even get the file URLs.
• Iowa: was on Socrata (CC BY 4.0), then migrated to a new "Iowa Data Hub" platform — all the documented legacy endpoints now 404.
• Hawaii: the full statewide registry (~442k) is on data.honolulu.gov, but the dataset carries no explicit license tag, so we left it disabled until commercial terms are confirmed.
• Washington, Illinois: publish business license data, not the registration registry.

What is this data good for?

Business registries are the skeleton of the US SMB economy: formation trends by county, entity-type shifts (the LLC-ification of everything), registered-agent market share, business survival analysis by cohort. We pulled this for company-matching in deciqAI's analysis engine, but honestly the dataset is more interesting than our use case. The fetcher is ~300 lines of Python stdlib, no dependencies. If you know of other states with genuinely open registries — or Iowa's new API docs — we'd love to hear about it.