Are the Insurance records on this page real?

No. Every record on this page is synthetic, generated from a fixed seed by the pack's own generator; masked values come from the real masking engine. The masking example uses a fixed public sample key; your own data is masked with a key from your secret store.

How long does a first certified Insurance dataset take?

Estimates, not guarantees — try the synthetic sandbox: minutes; install (or reuse) the agent: under an hour; connect a source: under an hour; review and approve policies: under an hour; first certified dataset: minutes.

Which test scenarios does the Insurance pack include?

12 runnable scenarios (everyday book, reopened claims, lapsed policies, catastrophe surge and more), plus 1 negative-test scenario kept apart from valid data.

Do Insurance rows leave my network?

No. The DataNivra agent runs inside your environment: it reads the source, masks, subsets, generates and certifies there, and sends only metadata, aggregate counts and evidence to the DataNivra control plane (customer-resident processing, zero raw-production-data egress).

Industry packs

Insurance industry pack

Policy and claim test data with every key and every interval intact.

Synthetic policy, claims, billing and distribution test data with linked masking

Fully self-service (journey proven end to end) Version 2.1.0 · Available in paid plans

The full Insurance 2.1.0 journey — from the public pack page through the synthetic sandbox, signup, activation, agent and source setup, scenario, masking and subsetting, certification and provisioning to evidence export — was verified end to end on a local real-component stack (the real control plane, agent, engine, sandbox runner, website and console built from source, with synthetic data) on 2026-10-09. Published agents 0.4.4, 0.4.3, 0.4.2, 0.4.1 and 0.4.0 run this pack version.

Try with synthetic data Activate this pack — start free

No call and no credit card needed. Prefer a conversation? Request a demo (optional). Missing something? Request a feature.

Included in Free Trial, Developer, Team, Business, Enterprise and Private Cloud / Self-Hosted. You can activate it for your organization yourself in the console; no call is needed.

Problems this pack solves

Masked data that still joins across 4 systems

6 cross-system relationships link billing, claims, distribution and policy_admin; the pack's masking keeps one pseudonym per identity on every side. For example, policy_admin.policyholders.policyholder_id and claims.claimants.policyholder_ref get the same pseudonym.

The cases production samples rarely contain

9 ready-made scenarios generate them on demand, for example: settled claims reopened for supplementary payments; policies lapsing after failed or returned premium collections, with failure reasons; A catastrophe event: many storm and water-damage claims within three days, one event code.

Sensitive fields found and masked before anyone sees them

48 columns across 10 entities are classified (direct identifier, financial, PHI, PII, quasi identifier and sensitive) and covered by 3 masking templates you review and approve.

Evidence that each dataset is fit to use

2 certification presets check masking coverage, referential integrity, orphans and row counts before a dataset can be provisioned; a failed dataset is never provisioned.

Entities and relationships

10 entities across 4 source systems, generated from the pack’s own entity model.

Arrows point from the referencing entity to the one it references. Solid: a foreign key inside one system. Dashed: a cross-system relationship — the pack keeps the same pseudonym on both sides, so masked data still joins.

All 13 relationships as a table

Relationships of the Insurance pack
Entity	References	Columns	Kind
Commission	Agent	`agent_id` → `agent_id`	Within a system
Policy	Policyholder	`policyholder_id` → `policyholder_id`	Within a system
Coverage	Policy	`policy_number` → `policy_number`	Within a system
Claimant	Claim	`claim_number` → `claim_number`	Within a system
ClaimPayment	Claim	`claim_number` → `claim_number`	Within a system
PremiumPayment	PremiumInvoice	`invoice_id` → `invoice_id`	Within a system
Policy	Agent	`agent_ref` → `agent_id`	Across systems (pack relationship template)
Commission	Policy	`policy_ref` → `policy_number`	Across systems (pack relationship template)
Claim	Policy	`policy_ref` → `policy_number`	Across systems (pack relationship template)
Claim	Coverage	`coverage_ref` → `coverage_id`	Across systems (pack relationship template)
Claimant	Policyholder	`policyholder_ref` → `policyholder_id`	Across systems (pack relationship template)
ClaimPayment	Claimant	`payee_claimant_id` → `claimant_id`	Within a system (pack relationship template)
PremiumInvoice	Policy	`policy_ref` → `policy_number`	Across systems (pack relationship template)

Realistic synthetic records

Synthetic data. Every record on this page is synthetic, generated from a fixed seed by the pack's own generator; masked values come from the real masking engine.

Entity

Policyholder — `policy_admin.policyholders` (synthetic)
`policyholder_id` sensitive	`given_name` sensitive	`family_name` sensitive	`birth_date` sensitive	`national_id` sensitive	`email` sensitive	`phone` sensitive	`street_address` sensitive	`city` sensitive	`postal_code` sensitive	`country_code`	`customer_since`
PH0000000001	Dorette	Langshaw	1965-08-15	NID-ZZ-6429646	dorette.kestholt3536@example.net	555-036-4135	3938 Ironleaf Lane	Estrwick	25495	ZZ	2022-06-14
PH0000000002	Elo	Yarrridge	1954-12-29	NID-ZZ-4607955	elo.oakley3703@example.net	—	2727 Zephyrine Way	Kelmhaven	80404	ZZ	2024-08-02

Masking: before and after

Template Linked insurance test data (INS_LINKED_TEST_DATA) applied to a synthetic Policyholder record from policy_admin.policyholders.

Synthetic record

Synthetic Policyholder record before and after masking
Column	Classified as	Before (synthetic)	After masking
`policyholder_id`	Direct identifier	`PH0000000001`	`PH5096215348`
`given_name`	PII, Direct identifier	`Dorette`	`Rosen`
`family_name`	PII, Direct identifier	`Langshaw`	`Thornridge`
`birth_date`	PII, Quasi identifier	`1965-08-15`	`1965-09-01`
`national_id`	PII, Direct identifier	`NID-ZZ-6429646`	`ZSG-SH-5451430`
`email`	PII, Direct identifier	`dorette.kestholt3536@example.net`	`vesira.quarrhart1102@example.org`
`phone`	PII, Direct identifier	`555-036-4135`	`555-052-1249`
`street_address`	PII, Quasi identifier	`3938 Ironleaf Lane`	`1045 Juniperwell Lane`
`city`	Quasi identifier	`Estrwick`	`Farrowby`
`postal_code`	PII, Quasi identifier	`25495`	`21824`

Same pseudonym in two systems. The identifier PH0000000001 appears in policy_admin.policyholders.policyholder_id and in claims.claimants.policyholder_ref. Both become PH5096215348, so the masked systems still join (relationship INS_CLAIMANT_POLICYHOLDER).

Masked with a fixed public sample key so this example is reproducible; your data is masked with your own key, referenced from your secret store.

Synthetic scenarios you can run

12 runnable scenarios. Run any of them in the hosted synthetic sandbox, or preview them in your browser without an account.

Everyday book

Normal INS_EVERYDAY_BOOK

An ordinary book of policies, coverages, claims, premium billing and commissions

Everyday, valid records: the baseline most tests expect. Children per parent record: 1–3.

Run in sandbox: Everyday book Preview in the browser demo: Everyday book

Reopened claims

Rare INS_REOPENED_CLAIMS

Settled claims reopened for supplementary payments

Valid but uncommon business situations that production samples often miss. Children per parent record: 1–3.

Run in sandbox: Reopened claims Preview in the browser demo: Reopened claims

Lapsed policies

Rare INS_LAPSED_POLICIES

Policies lapsing after failed or returned premium collections, with failure reasons

Valid but uncommon business situations that production samples often miss. Children per parent record: 1–3.

Run in sandbox: Lapsed policies Preview in the browser demo: Lapsed policies

Catastrophe surge

Rare INS_CATASTROPHE_SURGE

A catastrophe event: many storm and water-damage claims within three days, one event code

Valid but uncommon business situations that production samples often miss. Children per parent record: 2–5.

Run in sandbox: Catastrophe surge Preview in the browser demo: Catastrophe surge

Early claim review

Rare INS_EARLY_CLAIM_REVIEW

Claims flagged for fraud-indicator review (e.g. losses soon after inception); flags only

Valid but uncommon business situations that production samples often miss. Children per parent record: 1–2.

Run in sandbox: Early claim review Preview in the browser demo: Early claim review

High severity claims

Boundary INS_HIGH_SEVERITY_CLAIMS

Claims with reserves at or above the high-severity threshold (exactly at it for every tenth row)

Values at the edges of valid ranges (limits, thresholds, extremes). Children per parent record: 1–2.

Run in sandbox: High severity claims Preview in the browser demo: High severity claims

Claim payment edge cases

Boundary INS_CLAIM_PAYMENT_EDGE_CASES

Claim payments at the edges: one-cent and round-threshold amounts, voided and returned payments, subrogation recoveries, on settled or reopened claims

Values at the edges of valid ranges (limits, thresholds, extremes). Children per parent record: 2–4.

Run in sandbox: Claim payment edge cases Preview in the browser demo: Claim payment edge cases

Bodily injury claims

Rare INS_BODILY_INJURY_CLAIMS

Injured parties on claims, with synthetic injury narratives and diagnosis codes

Valid but uncommon business situations that production samples often miss. Children per parent record: 1–3.

Run in sandbox: Bodily injury claims Preview in the browser demo: Bodily injury claims

Policy renewals

Normal INS_POLICY_RENEWALS

Policies renewed on their anniversary: an expiring one-year term and the renewal term of the same product line starting the next day, re-rated between -8 and +22 percent; one renewal offer in five is declined (renewal term cancelled)

Everyday, valid records: the baseline most tests expect. Children per parent record: 2.

Run in sandbox: Policy renewals Preview in the browser demo: Policy renewals

Claim disputes

Rare INS_CLAIM_DISPUTES

Claimants disputing a denial or a settlement amount, with a reason; overturned decisions reopen the claim, upheld ones stand, some disputes are withdrawn

Valid but uncommon business situations that production samples often miss. Children per parent record: 1–3.

Run in sandbox: Claim disputes Preview in the browser demo: Claim disputes

Duplicate claims

Duplicate INS_DUPLICATE_CLAIMS

Claims notified twice with identical content under new claim numbers

Records that repeat others under new keys (clean-up and matching tests). Children per parent record: 2–4.

Run in sandbox: Duplicate claims Preview in the browser demo: Duplicate claims

Policy histories

Historical INS_POLICY_HISTORIES

Multi-year, referentially intact policy, claim and billing histories without gaps

Old records for archive, migration and retention tests. Children per parent record: 2–4.

Run in sandbox: Policy histories Preview in the browser demo: Policy histories

Negative tests, kept apart. This scenario produces deliberately broken data for error handling and never passes certification as valid data:

INS_BROKEN_REFERENCES — Dangling cross-system references and invalid values for error-handling tests

Sample schemas and representative outputs

The schema the pack expects in each system (also as CREATE TABLE DDL in the downloads). A run produces a masked or synthetic dataset with the same tables, a certification report with the gates of the chosen preset, and an evidence manifest with checksums — the rows stay in your environment.

Agent — distribution.agents · 9 columns

A licensed agent or broker who sells and services policies.

Column	Type	Required	Sensitive classes
`agent_id` (key)	`VARCHAR(12)`	Yes	Direct identifier
`agent_name`	`VARCHAR(96)`	Yes	PII, Direct identifier
`agency_name`	`VARCHAR(96)`	Yes	—
`license_number`	`VARCHAR(16)`	Yes	PII, Direct identifier
`email`	`VARCHAR(128)`	No	PII, Direct identifier
`phone`	`VARCHAR(32)`	No	PII, Direct identifier
`channel`	`VARCHAR(20)`	Yes	—
`status`	`VARCHAR(12)`	Yes	—
`appointed_on`	`DATE`	Yes	—

Commission — distribution.commissions · 7 columns

Commission an agent earns on a policy for a period.

Column	Type	Required	Sensitive classes
`commission_id` (key)	`BIGINT`	Yes	—
`agent_id`	`VARCHAR(12)`	Yes	Direct identifier
`policy_ref`	`VARCHAR(12)`	Yes	Direct identifier
`period_start`	`DATE`	Yes	—
`commission_rate`	`DOUBLE`	Yes	—
`commission_amount`	`DECIMAL(12,2)`	Yes	Financial
`status`	`VARCHAR(12)`	Yes	—

Policyholder — policy_admin.policyholders · 12 columns

A person holding one or more policies (the natural subset root).

Column	Type	Required	Sensitive classes
`policyholder_id` (key)	`VARCHAR(12)`	Yes	Direct identifier
`given_name`	`VARCHAR(64)`	Yes	PII, Direct identifier
`family_name`	`VARCHAR(64)`	Yes	PII, Direct identifier
`birth_date`	`DATE`	No	PII, Quasi identifier
`national_id`	`VARCHAR(16)`	No	PII, Direct identifier
`email`	`VARCHAR(128)`	No	PII, Direct identifier
`phone`	`VARCHAR(32)`	No	PII, Direct identifier
`street_address`	`VARCHAR(128)`	No	PII, Quasi identifier
`city`	`VARCHAR(64)`	No	Quasi identifier
`postal_code`	`VARCHAR(10)`	No	PII, Quasi identifier
`country_code`	`VARCHAR(2)`	Yes	—
`customer_since`	`DATE`	Yes	—

Policy — policy_admin.policies · 10 columns

An insurance contract held by a policyholder and sold by an agent.

Column	Type	Required	Sensitive classes
`policy_number` (key)	`VARCHAR(12)`	Yes	Direct identifier
`policyholder_id`	`VARCHAR(12)`	Yes	Direct identifier
`agent_ref`	`VARCHAR(12)`	Yes	Direct identifier
`product_line`	`VARCHAR(12)`	Yes	—
`status`	`VARCHAR(12)`	Yes	—
`inception_date`	`DATE`	Yes	—
`expiry_date`	`DATE`	Yes	—
`annual_premium`	`DECIMAL(12,2)`	Yes	Financial
`payment_frequency`	`VARCHAR(10)`	Yes	—
`currency_code`	`VARCHAR(3)`	Yes	—

Coverage — policy_admin.coverages · 6 columns

A covered peril or benefit on a policy, with its limit and deductible.

Column	Type	Required	Sensitive classes
`coverage_id` (key)	`BIGINT`	Yes	—
`policy_number`	`VARCHAR(12)`	Yes	Direct identifier
`coverage_code`	`VARCHAR(8)`	Yes	—
`peril`	`VARCHAR(24)`	Yes	—
`limit_amount`	`DECIMAL(12,2)`	Yes	—
`deductible_amount`	`DECIMAL(12,2)`	Yes	—

Claim — claims.claims · 14 columns

A loss notified against a coverage of a policy.

Column	Type	Required	Sensitive classes
`claim_number` (key)	`VARCHAR(12)`	Yes	Direct identifier
`policy_ref`	`VARCHAR(12)`	Yes	Direct identifier
`coverage_ref`	`BIGINT`	Yes	—
`loss_date`	`DATE`	Yes	Quasi identifier
`reported_at`	`TIMESTAMP`	Yes	—
`loss_cause`	`VARCHAR(24)`	Yes	—
`status`	`VARCHAR(20)`	Yes	—
`reserve_amount`	`DECIMAL(12,2)`	Yes	Financial
`catastrophe_code`	`VARCHAR(10)`	No	—
`fraud_review_flag`	`BOOLEAN`	Yes	—
`loss_description`	`VARCHAR(400)`	No	Sensitive
`adjuster_id`	`VARCHAR(12)`	No	Direct identifier
`dispute_status`	`VARCHAR(12)`	No	—
`dispute_reason`	`VARCHAR(24)`	No	—

Claimant — claims.claimants · 12 columns

A person involved in a claim: the insured, a third party, an injured party or a witness.

Column	Type	Required	Sensitive classes
`claimant_id` (key)	`BIGINT`	Yes	—
`claim_number`	`VARCHAR(12)`	Yes	Direct identifier
`policyholder_ref`	`VARCHAR(12)`	No	Direct identifier
`role`	`VARCHAR(16)`	Yes	—
`given_name`	`VARCHAR(64)`	Yes	PII, Direct identifier
`family_name`	`VARCHAR(64)`	Yes	PII, Direct identifier
`birth_date`	`DATE`	No	PII, Quasi identifier
`national_id`	`VARCHAR(16)`	No	PII, Direct identifier
`phone`	`VARCHAR(32)`	No	PII, Direct identifier
`street_address`	`VARCHAR(128)`	No	PII, Quasi identifier
`injury_description`	`VARCHAR(400)`	No	PHI, Sensitive
`diagnosis_code`	`VARCHAR(8)`	No	PHI

ClaimPayment — claims.claim_payments · 9 columns

A payment on a claim to one of its claimants (or a recovery from a third party).

Column	Type	Required	Sensitive classes
`payment_id` (key)	`BIGINT`	Yes	—
`claim_number`	`VARCHAR(12)`	Yes	Direct identifier
`payee_claimant_id`	`BIGINT`	Yes	—
`payment_type`	`VARCHAR(24)`	Yes	—
`paid_amount`	`DECIMAL(12,2)`	Yes	Financial
`paid_on`	`DATE`	Yes	—
`payee_iban`	`VARCHAR(34)`	No	Financial, Direct identifier
`payment_reference`	`VARCHAR(20)`	Yes	Financial, Direct identifier
`status`	`VARCHAR(12)`	Yes	—

PremiumInvoice — billing.premium_invoices · 6 columns

A premium bill for a policy instalment.

Column	Type	Required	Sensitive classes
`invoice_id` (key)	`BIGINT`	Yes	—
`policy_ref`	`VARCHAR(12)`	Yes	Direct identifier
`issued_on`	`DATE`	Yes	—
`due_date`	`DATE`	Yes	—
`amount_due`	`DECIMAL(12,2)`	Yes	Financial
`status`	`VARCHAR(12)`	Yes	—

PremiumPayment — billing.premium_payments · 9 columns

A collection attempt against a premium invoice (direct debit, card or bank transfer).

Column	Type	Required	Sensitive classes
`payment_id` (key)	`BIGINT`	Yes	—
`invoice_id`	`BIGINT`	Yes	—
`method`	`VARCHAR(16)`	Yes	—
`amount`	`DECIMAL(12,2)`	Yes	Financial
`collected_at`	`TIMESTAMP`	Yes	—
`payer_iban`	`VARCHAR(34)`	No	Financial, Direct identifier
`mandate_reference`	`VARCHAR(20)`	No	Financial, Direct identifier
`status`	`VARCHAR(12)`	Yes	—
`failure_reason`	`VARCHAR(24)`	No	—

Compatible connectors

Verified with this pack version: PostgreSQL and Local files (Parquet / CSV). 25 more connectors are compatible by capability: they support what the pack needs, but have not been verified with this pack yet.

Connector	Status with Insurance
Local files (Parquet / CSV)	Verified with this pack
PostgreSQL	Verified with this pack
Amazon DynamoDB	Compatible by capability (not yet verified with this pack)
Amazon Redshift	Compatible by capability (not yet verified with this pack)
Amazon S3 / S3-compatible storage	Compatible by capability (not yet verified with this pack)
Apache Kafka	Compatible by capability (not yet verified with this pack)
Azure Blob Storage / Data Lake Storage	Compatible by capability (not yet verified with this pack)
Azure Cosmos DB	Compatible by capability (not yet verified with this pack)
Azure Synapse Analytics	Compatible by capability (not yet verified with this pack)
CockroachDB	Compatible by capability (not yet verified with this pack)
Databricks	Compatible by capability (not yet verified with this pack)
Generic SQL (SQLAlchemy)	Compatible by capability (not yet verified with this pack)
Google BigQuery	Compatible by capability (not yet verified with this pack)
HTTP APIs	Compatible by capability (not yet verified with this pack)
IBM Db2	Compatible by capability (not yet verified with this pack)
IBM Informix	Compatible by capability (not yet verified with this pack)
Mainframe files (EBCDIC / copybook)	Compatible by capability (not yet verified with this pack)
MariaDB	Compatible by capability (not yet verified with this pack)
Microsoft SQL Server	Compatible by capability (not yet verified with this pack)
MongoDB	Compatible by capability (not yet verified with this pack)
MySQL	Compatible by capability (not yet verified with this pack)
Oracle Database	Compatible by capability (not yet verified with this pack)
Parquet files	Compatible by capability (not yet verified with this pack)
Salesforce	Compatible by capability (not yet verified with this pack)
ServiceNow	Compatible by capability (not yet verified with this pack)
Snowflake	Compatible by capability (not yet verified with this pack)
SQLite (developer evaluation)	Compatible by capability (not yet verified with this pack)

Prerequisites and expected setup effort

You need

A DataNivra account; the Free Trial includes this pack.
One DataNivra agent inside your network (outbound HTTPS only) that ships Insurance 2.1.0.
Read-only access to a compatible source (verified with this pack: PostgreSQL, Local files (Parquet / CSV)).
A non-production target environment the agent may write test data to.
A masking key in your own secret store, referenced as vault://…, azure-kv://… or env://… (DataNivra only ever sees the reference).
For production sources, a second person who approves policies (separation of duties).

A DataNivra agent that reports its installed industry packs (releases after agent 0.3.0); the control plane runs a pack job only on an agent holding the exact active pack version with the catalogued integrity digest.

Expected setup effort (estimates)

Step	Estimate
Try the synthetic sandbox No install: sign up and open the sandbox.	Minutes (estimate)
Install (or reuse) the agent One Docker command or a Helm chart; outbound HTTPS only.	Under an hour (estimate)
Connect a source Register a read-only source through the existing connector workflow.	Under an hour (estimate)
Review and approve policies Create drafts from the Insurance templates, review and approve them.	Under an hour (estimate)
First certified dataset Run the first job; certification and evidence are produced automatically.	Minutes (estimate)

Certification presets in plain language

`INS_STRICT`

Every gate; full masking coverage; zero orphaned policies, coverages, claims, claimants, payments, invoices or commissions; exact row counts. Default for masked insurance test data.

Masking coverage of at least 100% of sensitive columns
No orphaned child records
Empty-value ratio may rise by at most 5%
Row counts must match exactly

16 gates it requires

POLICY_COVERAGE: every sensitive column is covered by an approved policy
MASKING_COMPLETION: masking finished on every covered column
REFERENTIAL_INTEGRITY: every reference still points at an existing record
SCHEMA_VALIDATION: the output schema matches the source schema
DATA_QUALITY: empty-value ratios stay within the preset’s drift limit
ROW_COUNT_RECONCILIATION: row counts match the plan within the tolerance
ORPHAN_DETECTION: no child record lost its parent
PROVENANCE: every row is tagged masked or synthetic
MANIFEST: a manifest lists every output table with checksums
POLICY_VERSION: the exact approved policy versions are recorded
ENGINE_VERSION: the engine version is recorded
CHECKSUMS: output checksums are recorded for later verification
IDENTITY_CONSISTENCY: linked identifiers got the same pseudonym in every system
SOURCE_READ_ONLY: the source was only read, never written
EGRESS_GUARD: no row-level data left the agent
CONNECTOR_HEALTH: the connectors stayed healthy during the run

`INS_SCENARIO_TESTING`

Every gate, with slightly relaxed NULL-ratio drift for scenario datasets whose business states (lapsed policies, failed collections, claims without injuries) leave optional fields empty.

Masking coverage of at least 100% of sensitive columns
No orphaned child records
Empty-value ratio may rise by at most 15%
Row counts must match exactly

16 gates it requires

POLICY_COVERAGE: every sensitive column is covered by an approved policy
MASKING_COMPLETION: masking finished on every covered column
REFERENTIAL_INTEGRITY: every reference still points at an existing record
SCHEMA_VALIDATION: the output schema matches the source schema
DATA_QUALITY: empty-value ratios stay within the preset’s drift limit
ROW_COUNT_RECONCILIATION: row counts match the plan within the tolerance
ORPHAN_DETECTION: no child record lost its parent
PROVENANCE: every row is tagged masked or synthetic
MANIFEST: a manifest lists every output table with checksums
POLICY_VERSION: the exact approved policy versions are recorded
ENGINE_VERSION: the engine version is recorded
CHECKSUMS: output checksums are recorded for later verification
IDENTITY_CONSISTENCY: linked identifiers got the same pseudonym in every system
SOURCE_READ_ONLY: the source was only read, never written
EGRESS_GUARD: no row-level data left the agent
CONNECTOR_HEALTH: the connectors stayed healthy during the run

Activate it and create your first certified dataset

Seven steps in the console, each linked below. Nothing needs DataNivra staff.

Activate the pack for your organization
Activation checks your plan, the pack's integrity digest and its dependencies, then enables Insurance 2.1.0.
Open pack activation in the console
Install or reuse your agent
One agent runs every pack you activate; it must report this pack version. Upgrade it if it does not.
Install the agent in the console
Connect a compatible source
Start with a connector verified with this pack: PostgreSQL, Local files (Parquet / CSV).
Connect a source in the console
Create policies from the pack templates
Create drafts from Linked insurance test data, Unlinked insurance analytics extract, Linked test data without claim health details; a second person approves them (separation of duties).
Create policies from templates in the console
Request your first dataset
Choose a scenario such as Everyday book (INS_EVERYDAY_BOOK), the subset size and relationship closure.
Request a dataset in the console
Certify
The run is certified against a preset such as INS_STRICT; a failed dataset is never provisioned.
See certification evidence in the console
Provision and keep the evidence
Provision the certified dataset to a non-production target, download the evidence and schedule refreshes.
Provision the dataset in the console

Downloads

Version 2.1.0, 61 files (233.7 KB), all synthetic and generated from the pack itself. Every file’s SHA-256 is listed in MANIFEST.json.

Start here (2)

QUICKSTART.md 2.8 KB · SHA-256 9bfc3ccb69e3…
TROUBLESHOOTING.md 4.7 KB · SHA-256 08afdc0b5ffc…

Entity–relationship diagram (2)

er-diagram.mmd 4.9 KB · SHA-256 a3c01f6da39b…
er-diagram.svg 7.6 KB · SHA-256 af1422f6c1af…

Sample schemas (5)

schema/billing.sql 1.3 KB · SHA-256 535822e9748e…
schema/claims.sql 2.7 KB · SHA-256 6b1d7a4c9432…
schema/distribution.sql 1.4 KB · SHA-256 3055831f07a4…
schema/entities.json 30.3 KB · SHA-256 5cc010e3e286…
schema/policy_admin.sql 2.4 KB · SHA-256 1c421b7062f7…

Policy templates (9)

policies/INS_ANALYTICS_UNLINKED.json 17.9 KB · SHA-256 5336459834c6…
policies/INS_CLAIMS_MEDICAL_MINIMISED.json 20.1 KB · SHA-256 3567b4b63ad0…
policies/INS_CLASSIFICATION.json 203 B · SHA-256 ef051df69437…
policies/INS_LINKED_TEST_DATA.json 20.1 KB · SHA-256 8b70d5a0b758…
policies/INS_REFRESH_WEEKLY.json 190 B · SHA-256 e54930bed540…
policies/INS_SCENARIO_TESTING.json 549 B · SHA-256 a0728ad1a443…
policies/INS_STRICT.json 549 B · SHA-256 df479db4f4bb…
policies/INS_SUBSET_DEFAULT.json 112 B · SHA-256 d46c49c10d7c…
policies/README.md 1.2 KB · SHA-256 9055ce8c2e1b…

API, CLI, SDK and CI/CD examples (10)

api/curl.sh 2.5 KB · SHA-256 e616eb5b2bce…
api/dataset-request.json 1.5 KB · SHA-256 f7ba897d09e6…
api/policy-approval.json 155 B · SHA-256 d55e632a5036…
api/policy-drafts.json 162 B · SHA-256 1e25229c4597…
api/provision.json 63 B · SHA-256 7f02a6a87792…
api/sandbox.json 37 B · SHA-256 eb52de2269bf…
ci/README.md 479 B · SHA-256 8dc9a457c6e3…
ci/github-actions.yml 1.8 KB · SHA-256 c6b981154546…
cli.md 1.7 KB · SHA-256 c0de94e00648…
sdk_example.py 1.6 KB · SHA-256 b6c95486553b…

Synthetic sample data (CSV, JSON, Parquet) (31)

synthetic/SYNTHETIC_MANIFEST.json 2.4 KB · SHA-256 cff6c82f0fbc…
synthetic/billing.premium_invoices.csv 1.4 KB · SHA-256 d92672049549…
synthetic/billing.premium_invoices.json 4.7 KB · SHA-256 086af8ab5bf9…
synthetic/billing.premium_invoices.parquet 2.5 KB · SHA-256 ee4f4be8f48b…
synthetic/billing.premium_payments.csv 2.1 KB · SHA-256 af4e6916dad0…
synthetic/billing.premium_payments.json 7.3 KB · SHA-256 fc73d51de2f0…
synthetic/billing.premium_payments.parquet 4.0 KB · SHA-256 5851847b6461…
synthetic/claims.claim_payments.csv 1.6 KB · SHA-256 c91e931c61d3…
synthetic/claims.claim_payments.json 4.9 KB · SHA-256 7fddf0bd7f16…
synthetic/claims.claim_payments.parquet 3.9 KB · SHA-256 077a0d337bcd…
synthetic/claims.claimants.csv 2.9 KB · SHA-256 fa3d3cbd99e3…
synthetic/claims.claimants.json 9.9 KB · SHA-256 48f2e9868bbd…
synthetic/claims.claimants.parquet 5.4 KB · SHA-256 8413aaa3e12e…
synthetic/claims.claims.csv 1.9 KB · SHA-256 6d3e54ce5717…
synthetic/claims.claims.json 5.3 KB · SHA-256 701fb1aad9d2…
synthetic/claims.claims.parquet 5.3 KB · SHA-256 2e86a300eba0…
synthetic/distribution.agents.csv 731 B · SHA-256 6c2736444f40…
synthetic/distribution.agents.json 1.4 KB · SHA-256 fe613b94a3c3…
synthetic/distribution.agents.parquet 3.4 KB · SHA-256 5a18bcde9a38…
synthetic/distribution.commissions.csv 1.3 KB · SHA-256 62ce30f53b76…
synthetic/distribution.commissions.json 4.5 KB · SHA-256 893b58b19695…
synthetic/distribution.commissions.parquet 2.9 KB · SHA-256 944ae91d6a7a…
synthetic/policy_admin.coverages.csv 1.3 KB · SHA-256 7a874594319e…
synthetic/policy_admin.coverages.json 4.9 KB · SHA-256 b063a2349a80…
synthetic/policy_admin.coverages.parquet 2.5 KB · SHA-256 3d6e235400a5…
synthetic/policy_admin.policies.csv 1.3 KB · SHA-256 2dc8c6b5df03…
synthetic/policy_admin.policies.json 4.0 KB · SHA-256 38db7280c48d…
synthetic/policy_admin.policies.parquet 3.5 KB · SHA-256 e0dfec9842bd…
synthetic/policy_admin.policyholders.csv 913 B · SHA-256 35125ed65763…
synthetic/policy_admin.policyholders.json 2.2 KB · SHA-256 1dbbdad8844e…
synthetic/policy_admin.policyholders.parquet 4.2 KB · SHA-256 028402b794fd…

Troubleshooting

The reason codes you can meet on the way, with the recovery step. Every code is also in the error-code catalog.

SANDBOX_PACK_NOT_OFFERED — Synthetic estate not offered: A requested synthetic estate (industry pack) is not available in the hosted sandbox. What to do: Start the sandbox with the default estates.
ENTITLEMENT_REQUIRED — Plan does not include this: Your plan does not include this feature or industry pack. What to do: Upgrade in Billing & Plan.
PACK_INTEGRITY_UNVERIFIED — Pack integrity not verified: This pack version was registered without an integrity digest, so it cannot be activated (fail closed). What to do: Ask your operator to re-register the pack catalogue with the current control-plane image (register-pack), then activate again.
PACK_DEPENDENCY_INACTIVE — Required pack not active: This pack depends on another industry pack that is not active for your organization. What to do: Activate the packs this pack depends on first, then activate it again.
AGENT_PACK_MISSING — No agent can run this industry pack: The job's agent does not report the pack (older agents report no packs at all), so the job was not sent. What to do: Upgrade the agent to a release that reports its installed packs and ships this pack, then run the request again.
AGENT_PACK_VERSION_INCOMPATIBLE — Industry pack version differs on the agent: The agent holds a different version of the pack than the one the job was approved for. What to do: Deploy an agent with the pack's active version, or roll the pack back in Industry packs.
AGENT_PACK_INTEGRITY_MISMATCH — Agent pack differs from the catalogue: The agent reports the pack's version with a different integrity digest than the catalogued one, so the job was not sent. What to do: Redeploy the agent from the official signed image for this release, then run the request again.
PACK_TEMPLATES_UNAVAILABLE — Pack templates not registered: This pack version was registered without its policy templates. What to do: Ask your operator to re-register the pack catalogue (register-pack); create policies manually meanwhile.
PACK_TEMPLATE_KEY_REF_REQUIRED — Masking key reference required: A selected template keeps identities linked across systems and needs your masking key reference. What to do: Provide key_ref, e.g. vault://your-vault/tdm-masking-key, then create the drafts again.
PACK_NOT_ENABLED — Industry pack not enabled: The industry pack is not enabled for this tenant. What to do: Enable the pack (if your plan includes it).

Frequently asked questions

Are the Insurance records on this page real?: No. Every record on this page is synthetic, generated from a fixed seed by the pack's own generator; masked values come from the real masking engine. The masking example uses a fixed public sample key; your own data is masked with a key from your secret store.
Can I activate the Insurance pack myself?: Included in Free Trial, Developer, Team, Business, Enterprise and Private Cloud / Self-Hosted. You can activate it for your organization yourself in the console; no call is needed.
Which databases and files does the Insurance pack work with?: Verified with this pack version: PostgreSQL and Local files (Parquet / CSV). 25 more connectors are compatible by capability: they support what the pack needs, but have not been verified with this pack yet.
How long does a first certified Insurance dataset take?: Estimates, not guarantees — try the synthetic sandbox: minutes; install (or reuse) the agent: under an hour; connect a source: under an hour; review and approve policies: under an hour; first certified dataset: minutes.
Which test scenarios does the Insurance pack include?: 12 runnable scenarios (everyday book, reopened claims, lapsed policies, catastrophe surge and more), plus 1 negative-test scenario kept apart from valid data.
Do Insurance rows leave my network?: No. The DataNivra agent runs inside your environment: it reads the source, masks, subsets, generates and certifies there, and sends only metadata, aggregate counts and evidence to the DataNivra control plane (customer-resident processing, zero raw-production-data egress).

Learn the concepts, then come back to activate

Regulatory context

Supports privacy programmes of insurers and their service providers by keeping policyholder and claimant data inside your environment and producing certification evidence. Detection rules for insurance data do not, by themselves, make any system compliant with insurance, health-information or privacy law.

Try with synthetic data Activate this pack — start free

No call and no credit card needed. Prefer a conversation? Request a demo (optional). Missing something? Request a feature.

Problems this pack solves

Masked data that still joins across 4 systems

The cases production samples rarely contain

Sensitive fields found and masked before anyone sees them

Evidence that each dataset is fit to use

Entities and relationships

Realistic synthetic records

Masking: before and after

Synthetic scenarios you can run

Everyday book

Reopened claims

Lapsed policies

Catastrophe surge

Early claim review

High severity claims

Claim payment edge cases

Bodily injury claims

Policy renewals

Claim disputes

Duplicate claims

Policy histories

Sample schemas and representative outputs

Compatible connectors

Prerequisites and expected setup effort

You need

Expected setup effort (estimates)

Certification presets in plain language

INS_STRICT

INS_SCENARIO_TESTING

Activate it and create your first certified dataset

Activate the pack for your organization

Install or reuse your agent

Connect a compatible source

Create policies from the pack templates

Request your first dataset

Certify

Provision and keep the evidence

Downloads

Troubleshooting

Frequently asked questions

Learn the concepts, then come back to activate

Regulatory context

`INS_STRICT`

`INS_SCENARIO_TESTING`