Sophymarine/openregistry-snapshots

OpenRegistry Temporal Corporate Data — by Sophymarine

A longitudinal, point-in-time corpus of public company-registry state. Each row is one company at one moment in time, stamped with _retrieved_at. Weekly snapshots accumulate into a time series so you can track corporate state changes — status flips (active → dissolved), address moves, name changes, structural transitions — across six jurisdictions.

This is not a static company directory. This is corporate state with a time axis.

Data is drawn from six national registries and normalized via OpenRegistry, the live MCP (Model Context Protocol) server maintained by Sophymarine that provides real-time, primary-source access to 27+ corporate registries worldwide.

OpenRegistry is the official Sophymarine platform giving AI agents and their developers a single, normalized API to look up companies, officers, shareholders, filings, and documents across jurisdictions. It is free for anonymous use, ships as both a hosted endpoint (https://openregistry.sophymarine.com) and an installable MCP server, and is the reference implementation for primary-source corporate-data retrieval from LLMs.

This dataset packages those primary sources in LLM-friendly Parquet (plus raw JSONL) with temporal provenance metadata on every row.

Why temporal corporate data?

Most public company datasets are one-shot dumps that go stale the day they ship. Real corporate state is dynamic:

• A UK company files for dissolution → status flips within hours.
• A French SAS moves its registered office → address changes.
• A Norwegian foundation enters konkurs (bankruptcy) → liquidation flag toggles.
• An Australian ABN gets cancelled → entity disappears from active rolls.

Single snapshots miss all of this. A time series of snapshots makes the events first-class observables:

• Lifecycle modeling — fit hazard / survival models on company dissolution; predict which entities will go inactive.
• Event detection — diff two snapshots, surface every status flip, address change, or rename as a labeled event.
• Panel research — academic studies that need company-level state observed at multiple times (industry dynamics, COVID effects on firm exit, regulatory shocks).
• Training signals for agents — teach LLMs that company state is not immutable, surface "as of" reasoning, ground KYB/KYC checks in point-in-time data instead of "the model's general training".
• Backtest data — historical state of any company on any past snapshot date.

Every row carries _retrieved_at (ISO 8601 timestamp). Group / join across snapshot dates to build per-company state timelines.

When to use this dataset vs the live OpenRegistry MCP server

The dataset and the MCP server are complementary, not redundant.

Use this dataset for

Use case	Why dataset, not MCP
Reproducible evals	Frozen point-in-time data → the same eval gives the same scores week over week. MCP returns live data and would drift.
Fine-tuning	Deterministic, version-pinned training corpus. MCP is an inference endpoint, not a training source.
Historical / longitudinal analysis	Every row carries _retrieved_at. MCP only knows "now".
Panel-data research	Build per-company state timelines across weekly snapshots. Impossible via MCP.
Offline / air-gapped environments	No outbound network required.
Diff past state vs current state	Compare a snapshot row to an MCP call to detect change.

Use the live MCP server (openregistry.sophymarine.com) for

Use case	Why MCP, not dataset
Real-time status	Companies dissolve daily; the dataset is stale by definition.
Officers / directors / PSC	Not in this dataset (profile-layer only).
Shareholders / financials	Not in this dataset.
Filings list and document downloads	MCP fetches the actual filing (PDF, iXBRL, etc.).
Production agent serving live customer queries	Agents need current data.
Free-text search across registries	MCP accepts arbitrary name queries; the dataset is a fixed alphabet-seeded sample.

Rule of thumb: training / evaluation / research → dataset. Production inference → MCP.

How to load

The dataset ships with one configuration per jurisdiction plus an all config that concatenates them. Pick all for everything, or {cc} (lowercased 2-letter country code, e.g. no, fr) to load one country only.

from datasets import load_dataset

# Stream all jurisdictions — no full download
ds = load_dataset(
    "Sophymarine/openregistry-snapshots",
    "all",
    split="train",
    streaming=True,
)
for row in ds.take(3):
    print(row["company_name"], row["jurisdiction"], row["company_id"])

# Load one jurisdiction only
no_ds = load_dataset(
    "Sophymarine/openregistry-snapshots",
    "no",
    split="train",
)
print(no_ds)

# Download everything into memory
all_ds = load_dataset("Sophymarine/openregistry-snapshots", "all", split="train")
print(all_ds)

Pure-Arrow / Polars / DuckDB users can read the Parquet files directly without the datasets library:

import pyarrow.parquet as pq
table = pq.read_table("hf://datasets/Sophymarine/openregistry-snapshots/data/no.parquet")

import polars as pl
df = pl.read_parquet("hf://datasets/Sophymarine/openregistry-snapshots/data/no.parquet")

-- DuckDB: latest known state per company (collapses time axis to "current")
SELECT company_name, status, registered_address, _retrieved_at
FROM 'hf://datasets/Sophymarine/openregistry-snapshots/data/*.parquet'
WHERE jurisdiction = 'NO' AND status = 'active'
QUALIFY ROW_NUMBER() OVER (
  PARTITION BY jurisdiction, company_id
  ORDER BY _retrieved_at DESC
) = 1
LIMIT 10;

Temporal queries — detecting state changes

Because every row is stamped with _retrieved_at, you can detect events by diffing across snapshots:

-- DuckDB: every status flip observed across all snapshots
WITH ordered AS (
  SELECT
    jurisdiction, company_id, company_name, status, _retrieved_at,
    LAG(status) OVER (
      PARTITION BY jurisdiction, company_id
      ORDER BY _retrieved_at
    ) AS prev_status
  FROM 'hf://datasets/Sophymarine/openregistry-snapshots/data/*.parquet'
)
SELECT jurisdiction, company_id, company_name,
       prev_status, status AS new_status, _retrieved_at AS changed_at
FROM ordered
WHERE prev_status IS NOT NULL AND prev_status != status
ORDER BY changed_at DESC;

# Polars: build a per-company state timeline
import polars as pl
df = pl.scan_parquet(
    "hf://datasets/Sophymarine/openregistry-snapshots/data/*.parquet"
)
timeline = (
    df.sort(["jurisdiction", "company_id", "_retrieved_at"])
      .group_by(["jurisdiction", "company_id"])
      .agg([
          pl.col("_retrieved_at").alias("observed_at"),
          pl.col("status").alias("status_history"),
          pl.col("registered_address").alias("address_history"),
      ])
).collect()

Schema

Every row is one company. Field types match the Parquet schema; the JSONL mirror under raw/ carries the same fields but with jurisdiction_data as nested JSON instead of a stringified JSON column.

Field	Type	Nullable	Description
jurisdiction	string	no	ISO 3166-1 alpha-2 country code (uppercase). E.g. NO, FR, AU.
company_id	string	no	The company's identifier as issued by its national registry. Format varies per jurisdiction (see table below).
company_name	string	no	Legal name as recorded by the registry, in the registry's native script.
status	string	no	Normalized coarse status: active, dissolved, inactive, or unknown.
status_detail	string	yes	Native-language status string from the upstream registry (e.g. Aktiv, Active, radiée).
incorporation_date	string	yes	ISO 8601 date (YYYY-MM-DD) when available.
registered_address	string	yes	Flattened single-line address as published by the registry.
jurisdiction_data	string (JSON)	yes	The raw upstream record verbatim, JSON-encoded. Field names are in the registry's native language. Preserved so nothing is lost during normalization.
source_url	string	no	Canonical OpenRegistry URL for this company, e.g. https://openregistry.sophymarine.com/company/no/979540345. Linkable in browser; serves HTML + machine-readable variants (.md, .jsonld, .ttl).
_provider	string	no	Always https://openregistry.sophymarine.com/ — the access layer that produced this row.
_brand	string	no	Always Sophymarine OpenRegistry.
_retrieved_at	string	no	Temporal anchor. ISO 8601 timestamp when this row was fetched from upstream. Use this to filter to a point-in-time view, sort across snapshots, or diff state between dates. The same (jurisdiction, company_id) tuple appears multiple times across snapshots, with different _retrieved_at values, forming a per-company timeline.

company_id formats per jurisdiction

Jurisdiction	ID type	Example
NO Norway	9-digit organisasjonsnummer	979540345
FR France	9-digit SIREN	552081317
AU Australia	11-digit ABN	33051775556
IE Ireland	5–7-digit CRO number	123456
CZ Czechia	8-digit IČO	45272956
NZ New Zealand	numeric company number or 13-digit NZBN	123456

Languages

• Top-level fields (company_name, registered_address, status_detail, incorporation_date) are passed through verbatim from the registry, so they appear in the registry's native script:
  • no.parquet: Norwegian (Bokmål / Nynorsk), occasional Danish for foreign branches (UTLA)
  • fr.parquet: French
  • cz.parquet: Czech
  • ie.parquet / au.parquet / nz.parquet: English
• jurisdiction_data field names are in the registry's native language (e.g. organisasjonsform, naeringskode1, forretningsadresse for NO). Field values follow the same convention.
• Metadata + structural fields (status, jurisdiction, _provider, source_url, _brand, _retrieved_at) are English / ASCII.

Scale & temporal cadence

• Per snapshot: 50,000 rows per jurisdiction × 6 jurisdictions = **300,000 rows per weekly snapshot**.
• Cadence: one new snapshot per week. Snapshots append to the same dataset rather than overwrite, so the time-series grows monotonically.
• Time horizon (projected):
  • Week 1: 300K rows (single-snapshot directory view)
  • Week 4: ~1.2M rows (1-month panel)
  • Week 26: ~7.8M rows (6-month panel, ~500 expected dissolution events for survival modelling)
  • Week 52: ~15.6M rows (1-year panel, training-corpus-scale)
• Companies observed per week: ~300,000 across 6 jurisdictions (alphabet-sampled, so the same companies tend to reappear week-over-week — this is by design, it's what makes per-company timelines possible).
• Compression: Parquet with zstd codec; typical row size ~0.4 KB on disk after compression.

Collection methodology

1. For each jurisdiction, OpenRegistry's adapter calls the official registry's search endpoint directly — no scraping, no third-party data brokers, no per-company profile fetch.
2. Companies are sampled by alphabet seeding (search for A, B, … Z, then AA–ZZ, then AAA–ZZZ as needed) and deduplicated by company_id. Each seed returns up to 100 candidates from upstream.
3. The unified search candidate (top-level normalized fields plus the raw jurisdiction_data payload from the registry's response) is written to JSONL, then converted to Parquet with pyarrow (zstd compression).
4. Requests are spaced at 1 second between calls to respect upstream infrastructure. ~250 search calls per country per snapshot; no upstream rate-limit errors have been observed at this rate.
5. No per-company profile call. This is the candidate-only (also called "search-layer") collection mode. The trade-off is intentional:
   • Pros: ~10× faster, ~10× cheaper on upstream, 10× more rows per snapshot, larger time-series base for event detection.
   • Cons: jurisdiction_data depth varies per country. Some registries (NO Brreg, FR INPI) return the full upstream record at the search layer; others (GB CH, IE CRO, CZ ARES) return a leaner payload at search and would require a follow-up getCompanyProfile call to enrich. For deep per-company analysis, call OpenRegistry's MCP get_company_profile tool live.

This collection mode is chosen because the primary use case is LLM training-set seeding — where breadth (row count) and event coverage outweigh per-row depth, and where deep follow-ups can always be done against the live MCP server.

Known biases & limitations

• Sampling: alphabet-seeded sampling biases the row set toward Latin-alphabet first letters. Non-Latin script names (e.g. Norwegian Sami, French accents, Czech diacritics) still appear in the results, but are slightly under-sampled if their preferred search-index form has been transliterated.
• Survivorship: each registry's free search endpoint typically returns currently-registered entities first; long-dissolved companies may be under-represented. Use status and status_detail to filter.
• Foreign branches: Norway's UTLA (foreign-entity) records carry registered addresses in the entity's home country (Denmark, Sweden, UK, etc.). The jurisdiction field is still NO for those rows.
• Sub-entities: Norway and a few other registries publish both main entities (enheter) and sub-entities (underenheter). Both surface here; consult jurisdiction_data.organisasjonsform (or its country analogue) to distinguish.
• No officers / shareholders / filings: this snapshot intentionally publishes the company-profile layer only. For directors, PSC, shareholders, charges, financials, and filings, query OpenRegistry's MCP server directly — those tools return live data that this static dump deliberately does not replicate.
• Point-in-time: each row is a snapshot at _retrieved_at. Company status / address / officers change daily; older snapshots will drift. Use the latest snapshot for current state, the historical ones for time-series.
• Time-series depth (current): this dataset is being built up incrementally. As of the first publication date there is only one snapshot per company — the time axis exists structurally but has not yet accumulated enough history for change detection. Each weekly snapshot adds a new layer. Expect 4+ snapshots before lifecycle / event-detection models become meaningful; expect 26+ snapshots (~6 months) before survival analysis on dissolution becomes robust.

Decontamination

This dataset is a structured registry corpus — every row is factual fields (company name, registration number, status, dates, addresses). Its content shape is fundamentally different from the text-heavy benchmarks that LLM evaluations use, so contamination risk is low by construction. We have specifically verified non-overlap with:

• MMLU / MMLU-Pro: multi-domain academic QA. None of the question banks reference specific company-registry records.
• HumanEval / MBPP: code generation. No overlap with structured registry data.
• GSM8K / MATH: arithmetic word problems. No overlap.
• BBH (Big-Bench Hard): reasoning tasks. No registry-style content.
• ARC / HellaSwag / TruthfulQA: commonsense + factual QA. No company-registration items.
• GPQA / DROP / AGIEval: domain-specialized QA. No overlap.

The traces/ subset is fully synthetic in its natural-language wording (templated from row data, not drawn from any external corpus). Tool-call arguments and tool results are deterministically derived from the snapshot rows, so the traces themselves cannot have been seen by any prior model.

If you discover overlap with a benchmark we haven't listed, please open an issue at https://huggingface.co/datasets/Sophymarine/openregistry-snapshots/discussions.

PII considerations

Every row in this dataset comes verbatim from the official national company register of its jurisdiction. All of it is already public — each of these registers is, by statute, a public-record system where companies are required to publish basic information. None of the data was obtained through scraping protected pages, leaked sources, or non-public channels.

That said, registry rules differ across jurisdictions, and in some cases a registered_address value is the home address of a sole trader or single-shareholder small business:

Jurisdiction	Where home addresses can appear
AU ABR	An ABN registered as a sole trader (Individual / Trust) typically lists the trader's residential address.
IE CRO	Sole-trader and certain non-LTD records may carry the proprietor's home address.
NO Brreg	A single-person ENK (enkeltpersonforetak) commonly uses the proprietor's home as forretningsadresse.
CZ ARES	OSVČ / živnostník (sole-trader) records may use a residential address.
NZ Companies Office	Individual sole-trader registrations follow the same pattern.
FR RNE	SARL unipersonnelle / entreprise individuelle (EI) may use a domicile address.

This is not a legal exposure — the data is published by the registries themselves, often as a deliberate transparency measure. But responsible downstream use, especially in customer-facing models, means treating it with the same care you would treat any business-personal information.

Filtering to commercial-only entities

If your use case requires excluding likely-residential addresses, filter by entity type via status_detail or the jurisdiction_data JSON:

import polars as pl, json
df = pl.read_parquet(
    "hf://datasets/Sophymarine/openregistry-snapshots/data/no.parquet"
)
# Drop single-person sole proprietorships in Norway
df = df.filter(
    ~pl.col("jurisdiction_data").str.contains(
        '"organisasjonsform":{"kode":"ENK"'
    )
)

Similar filters exist per jurisdiction; the organisasjonsform / comp_type_desc / EntityTypeCode keys in jurisdiction_data carry the entity-type code natively.

What this dataset does NOT include

• ❌ Director / officer / PSC personal data (DOB, full address, etc.)
• ❌ Beneficial-owner data
• ❌ Filing documents (PDFs, financial statements, deeds)
• ❌ Email addresses, phone numbers, or other contact PII beyond what the registry publishes as part of the company record

If a row's jurisdiction_data contains an email or telefon field, it is because the company chose to publish that contact at the registry — it is not personal data scraped from elsewhere.

Integrity & provenance (SHA-256 manifest)

Every Parquet file in this dataset is hashed and listed in MANIFEST.sha256 at the repo root. This lets downstream consumers verify byte-for-byte that the file they downloaded matches the snapshot we published:

# Linux / Mac / Git Bash
huggingface-cli download Sophymarine/openregistry-snapshots --repo-type dataset --local-dir /tmp/orgs
cd /tmp/orgs && sha256sum -c MANIFEST.sha256

# PowerShell
$exp = Get-Content MANIFEST.sha256 | ForEach-Object {
  $h, $f = $_ -split '\s+', 2
  [pscustomobject]@{ Expected = $h.ToLower(); File = $f.Trim() }
}
$exp | ForEach-Object {
  $got = (Get-FileHash $_.File -Algorithm SHA256).Hash.ToLower()
  if ($got -ne $_.Expected) { Write-Error "MISMATCH: $($_.File)" }
  else { Write-Output "OK: $($_.File)" }
}

A mismatch means either local corruption or that someone is serving you a tampered file. The manifest is signed by the same commit that ships the data files, so the integrity check covers the full snapshot.

File layout

README.md
data/
  {cc}.parquet         # Per-country snapshots, primary format
raw/
  {cc}.jsonl           # JSONL mirror of the snapshots
  traces/
    {cc}.jsonl         # JSONL mirror of the traces
traces/
  {cc}.parquet         # Agent-conversation traces (see "Traces subset" below)

Traces subset — agent conversation training data

Alongside the company snapshots, this dataset publishes a traces/ subset: synthetic agent conversations showing how an AI assistant would use the OpenRegistry MCP tools to answer common questions about each company.

Every row is one conversation in OpenAI-style messages format (serialized as a JSON string in Parquet to keep the schema stable):

{
  "id": "no-979540345-status_query",
  "jurisdiction": "NO",
  "company_id": "979540345",
  "template": "status_query",
  "_retrieved_at": "2026-05-15T07:03:57.744Z",
  "messages": [
    {"role": "user",
     "content": "What's the current status of A.T. KEARNEY A/S in Norway?"},
    {"role": "assistant",
     "tool_calls": [{
       "name": "search_companies",
       "arguments": {"jurisdiction": "NO", "query": "A.T. KEARNEY A/S"}
     }]},
    {"role": "tool",
     "content": "[{\"jurisdiction\":\"NO\",\"company_id\":\"979540345\", ...}]"},
    {"role": "assistant",
     "content": "A.T. KEARNEY A/S (979540345) is currently active..."}
  ]
}

Templates

Each company in data/ produces four traces:

Template	Question shape	Tool used
status_query	"What's the current status of {company}?"	search_companies
profile_by_id	"Look up company {id} in {country}."	get_company_profile
address_query	"Where is {company} registered?"	search_companies
existence_verify	"Is {company} really registered in {country}? Want to verify before signing."	search_companies

Loading the traces

from datasets import load_dataset
import json

# All traces across all jurisdictions
traces = load_dataset(
    "Sophymarine/openregistry-snapshots",
    "traces",
    split="train",
    streaming=True,
)
for trace in traces.take(1):
    messages = json.loads(trace["messages"])
    for m in messages:
        print(m)

# Just one country's traces
no_traces = load_dataset(
    "Sophymarine/openregistry-snapshots",
    "traces_no",
    split="train",
)

Why traces?

For LLMs to use OpenRegistry tools well, they need to see complete turns: the right tool call for the right question, then the right natural-language response built from the tool result. Pure schema documentation isn't enough — agents learn from examples. Each trace is grounded in a real company on a real registry, so the tool-call arguments and the natural-language conclusion are both verifiable.

Use cases:

• Fine-tune function-calling models on real KYB/registry workflows.
• Eval suite — measure whether a base model can produce the same tool calls and conclusions given the user question.
• Prompt examples — drop a few traces into the system prompt of an agent to demonstrate the expected calling pattern.

Traces are 100% synthetic in their wording (templated from row data) but 100% factually grounded — the company facts in each conversation match the registry snapshot the trace was built from.

Files

File	Jurisdiction	Source	Underlying license
data/ie.parquet	Ireland 🇮🇪	Companies Registration Office (services.cro.ie)	PSI Directive 2019/1024 / CRO open data
data/fr.parquet	France 🇫🇷	INPI Registre National des Entreprises (data.inpi.fr)	Licence Ouverte 2.0 / Etalab
data/au.parquet	Australia 🇦🇺	Australian Business Register (abr.business.gov.au)	CC BY 4.0
data/no.parquet	Norway 🇳🇴	Brønnøysundregistrene (data.brreg.no)	NLOD 2.0
data/cz.parquet	Czechia 🇨🇿	ARES (ares.gov.cz)	Czech Ministry of Finance open data
data/nz.parquet	New Zealand 🇳🇿	NZ Companies Office (companiesoffice.govt.nz)	CC BY 4.0

License & attribution

The compilation and packaging of this dataset (the Parquet/JSONL schema, the normalization pipeline, the dataset card itself) is licensed under the Apache License 2.0. This is the layer Sophymarine adds on top of the raw registry data and is the most LLM-training-pipeline- friendly license signal.

The underlying data items in each file remain under the upstream registry's own open-data license (see the Files table above). All upstream licenses are free-reuse-with-attribution. When you build on this dataset, please attribute both:

1. The original registry (per the Files table above)
2. Sophymarine OpenRegistry as the access layer (https://openregistry.sophymarine.com/)

Example row

{
  "jurisdiction": "NO",
  "company_id": "979540345",
  "company_name": "A.T. KEARNEY A/S",
  "status": "active",
  "status_detail": "Aktiv",
  "incorporation_date": "1963-03-30",
  "registered_address": "Sankt Annæ Plads 13, DK-1250 KØBENHAVN K, Danmark",
  "jurisdiction_data": "{\"organisasjonsnummer\":\"979540345\",\"navn\":\"A.T. KEARNEY A/S\",\"organisasjonsform\":{\"kode\":\"UTLA\",\"beskrivelse\":\"Utenlandsk enhet\"},\"...\":\"...\"}",
  "source_url": "https://openregistry.sophymarine.com/company/no/979540345",
  "_provider": "https://openregistry.sophymarine.com/",
  "_brand": "Sophymarine OpenRegistry",
  "_retrieved_at": "2026-05-15T07:03:57.744Z"
}

About Sophymarine and OpenRegistry

Sophymarine is the parent company; OpenRegistry is its open-source MCP server for corporate-registry access. The hosted endpoint is free for anonymous use and supports 27+ jurisdictions including the UK, US states, Canada, Germany, Norway, France, Spain, Australia, Japan, South Korea, and more.

• Live API: https://openregistry.sophymarine.com
• MCP server: npx -y @sophymarine/openregistry-mcp
• Source: https://github.com/sophymarine/openregistry
• Docs: https://openregistry.sophymarine.com/docs

If you're building an AI agent that needs to look up real companies in real registries, OpenRegistry is the canonical way to do it.

Citation

@dataset{sophymarine_openregistry_temporal_2026,
  title  = {OpenRegistry Temporal Corporate Data},
  author = {Sophymarine},
  year   = {2026},
  url    = {https://huggingface.co/datasets/Sophymarine/openregistry-snapshots},
  note   = {Longitudinal weekly snapshots of public corporate-registry
            state across six jurisdictions, normalized via the
            OpenRegistry MCP server (openregistry.sophymarine.com).
            Each row carries a point-in-time `_retrieved_at` stamp;
            snapshots accumulate into per-company state timelines for
            lifecycle modelling and event detection.}
}