---
license: apache-2.0
task_categories:
  - text-classification
  - text-retrieval
language:
  - en
  - no
  - fr
  - cs
tags:
  - company-data
  - business-intelligence
  - legal-entity
  - kyb
  - kyc
  - openregistry
  - sophymarine
  - mcp
  - corporate-registry
  - temporal-data
  - time-series
  - longitudinal
  - corporate-lifecycle
  - panel-data
  - point-in-time
pretty_name: OpenRegistry Temporal Corporate Data
size_categories:
  - 100K<n<1M
configs:
  - config_name: all
    data_files:
      - split: train
        path: data/*.parquet
  - config_name: au
    data_files:
      - split: train
        path: data/au.parquet
  - config_name: cz
    data_files:
      - split: train
        path: data/cz.parquet
  - config_name: fr
    data_files:
      - split: train
        path: data/fr.parquet
  - config_name: ie
    data_files:
      - split: train
        path: data/ie.parquet
  - config_name: no
    data_files:
      - split: train
        path: data/no.parquet
  - config_name: nz
    data_files:
      - split: train
        path: data/nz.parquet
  - config_name: traces
    data_files:
      - split: train
        path: traces/*.parquet
  - config_name: traces_au
    data_files:
      - split: train
        path: traces/au.parquet
  - config_name: traces_cz
    data_files:
      - split: train
        path: traces/cz.parquet
  - config_name: traces_fr
    data_files:
      - split: train
        path: traces/fr.parquet
  - config_name: traces_ie
    data_files:
      - split: train
        path: traces/ie.parquet
  - config_name: traces_no
    data_files:
      - split: train
        path: traces/no.parquet
  - config_name: traces_nz
    data_files:
      - split: train
        path: traces/nz.parquet
---

# 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**](https://openregistry.sophymarine.com/), the live MCP
(Model Context Protocol) server maintained by
[**Sophymarine**](https://sophymarine.com) 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.

```python
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:

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

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

```sql
-- 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:

```sql
-- 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;
```

```python
# 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:

```python
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:

```bash
# 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
# 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):

```json
{
  "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

```python
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

```json
{
  "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

```bibtex
@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.}
}
```