Are the Retail & E-commerce 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 Retail & E-commerce 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 Retail & E-commerce pack include?

10 runnable scenarios (everyday shopping, flash sale peak, abandoned carts, returns and refunds and more), plus 1 negative-test scenario kept apart from valid data.

Do Retail & E-commerce 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

Retail & E-commerce industry pack

Synthetic e-commerce orders, payments, shipments and returns with linked masking

Preview only · not activatable yet Version 2.0.0 · Complete

Try with synthetic data Notify me — tell us you need it

Everything on this page works without an account. Prefer a conversation? Request a demo (optional). Missing something? Request a feature.

This pack is installed and passes DataNivra’s pack conformance kit through the real engine, but it cannot be activated yet: no plan includes it yet, the standard agent image does not ship it, the control-plane catalogue does not list it and the hosted sandbox has no synthetic estate for it. You can explore its synthetic records, masking and scenarios on this page and in the browser demo. Tell us if you need it: demand decides which packs become activatable next.

Problems this pack solves

Masked data that still joins across 4 systems

6 cross-system relationships link fulfilment, loyalty, orders and storefront; the pack's masking keeps one pseudonym per identity on every side. For example, storefront.shoppers.shopper_id and orders.orders.shopper_ref get the same pseudonym.

The cases production samples rarely contain

8 ready-made scenarios generate them on demand, for example: A flash sale: many app orders and payments within a two-hour window; carts left without checkout; partially returned orders with refunds and free-text return comments.

Sensitive fields found and masked before anyone sees them

40 columns across 12 entities are classified (direct identifier, financial, payment, 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

12 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 16 relationships as a table

Relationships of the Retail & E-commerce pack
Entity	References	Columns	Kind
ShopperAddress	Shopper	`shopper_id` → `shopper_id`	Within a system
Cart	Shopper	`shopper_id` → `shopper_id`	Within a system
CartItem	Cart	`cart_id` → `cart_id`	Within a system
CartItem	Product	`product_sku` → `product_sku`	Within a system
Review	Shopper	`shopper_id` → `shopper_id`	Within a system
Review	Product	`product_sku` → `product_sku`	Within a system
OrderLine	Order	`order_number` → `order_number`	Within a system
Payment	Order	`order_number` → `order_number`	Within a system
Return	Order	`order_number` → `order_number`	Within a system
Order	Shopper	`shopper_ref` → `shopper_id`	Across systems (pack relationship template)
Order	ShopperAddress	`shipping_location_ref` → `location_id`	Across systems (pack relationship template)
Order	Cart	`cart_ref` → `cart_id`	Across systems (pack relationship template)
OrderLine	Product	`product_sku` → `product_sku`	Across systems (pack relationship template)
Return	OrderLine	`line_ref` → `line_id`	Within a system (pack relationship template)
Shipment	Order	`order_ref` → `order_number`	Across systems (pack relationship template)
LoyaltyAccount	Shopper	`shopper_ref` → `shopper_id`	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

Shopper — `storefront.shoppers` (synthetic)
`shopper_id` sensitive	`given_name` sensitive	`family_name` sensitive	`email` sensitive	`phone` sensitive	`birth_date` sensitive	`last_ip_address` sensitive	`marketing_opt_in`	`signed_up_at`
SHP000000001	Tamo	Kestshaw	tamo.hollofield2048@example.com	555-048-9920	—	198.51.100.95	false	2021-01-08T08:52:44
SHP000000002	Selan	Vallridge	selan.holloridge8135@example.org	555-035-4981	—	198.51.100.114	true	2020-08-03T00:02:13

Masking: before and after

Template Linked e-commerce test data (RET_LINKED_TEST_DATA) applied to a synthetic Shopper record from storefront.shoppers.

Synthetic record

Synthetic Shopper record before and after masking
Column	Classified as	Before (synthetic)	After masking
`shopper_id`	Direct identifier	`SHP000000001`	`SHP098977906`
`given_name`	PII, Direct identifier	`Tamo`	`Marira`
`family_name`	PII, Direct identifier	`Kestshaw`	`Caldfield`
`email`	PII, Direct identifier	`tamo.hollofield2048@example.com`	`selric.yarrholt4319@example.org`
`phone`	PII, Direct identifier	`555-048-9920`	`555-011-0834`
`birth_date`	PII, Quasi identifier	`—`	`—` (same value after masking)
`last_ip_address`	PII, Quasi identifier	`198.51.100.95`	`009.17.346.24`

Same pseudonym in two systems. The identifier SHP000000001 appears in storefront.shoppers.shopper_id and in orders.orders.shopper_ref. Both become SHP098977906, so the masked systems still join (relationship RET_ORDER_SHOPPER).

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

10 runnable scenarios. Preview them in your browser without an account; the hosted sandbox opens when the pack becomes activatable.

Everyday shopping

Normal RET_EVERYDAY_SHOPPING

Ordinary shoppers, carts, orders, payments, deliveries and loyalty accounts

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

Preview in the browser demo: Everyday shopping

Flash sale peak

Rare RET_FLASH_SALE_PEAK

A flash sale: many app orders and payments within a two-hour window

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

Preview in the browser demo: Flash sale peak

Abandoned carts

Rare RET_ABANDONED_CARTS

Carts left without checkout

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

Preview in the browser demo: Abandoned carts

Returns and refunds

Rare RET_RETURNS_AND_REFUNDS

Partially returned orders with refunds and free-text return comments

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

Preview in the browser demo: Returns and refunds

Payment declines

Rare RET_PAYMENT_DECLINES

Declined card payments, each with a decline reason

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

Preview in the browser demo: Payment declines

Split shipments

Rare RET_SPLIT_SHIPMENTS

Orders shipped in several parcels, some of which fail delivery

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

Preview in the browser demo: Split shipments

Long reviews

Rare RET_LONG_REVIEWS

Reviews with long free text (synthetic) to exercise free-text detection and redaction

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

Preview in the browser demo: Long reviews

Promo abuse review

Rare RET_PROMO_ABUSE_REVIEW

Orders flagged for promotion-abuse review (a flag only, not a finding)

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

Preview in the browser demo: Promo abuse review

Large orders

Boundary RET_LARGE_ORDERS

Order totals at or above the large-order threshold (exactly at it for every tenth row)

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

Preview in the browser demo: Large orders

Duplicate orders

Duplicate RET_DUPLICATE_ORDERS

Orders submitted twice with identical content under new order numbers

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

Preview in the browser demo: Duplicate orders

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

RET_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.

Shopper — storefront.shoppers · 9 columns

A registered shopper account (the natural subset root).

Column	Type	Required	Sensitive classes
`shopper_id` (key)	`VARCHAR(12)`	Yes	Direct identifier
`given_name`	`VARCHAR(64)`	Yes	PII, Direct identifier
`family_name`	`VARCHAR(64)`	Yes	PII, Direct identifier
`email`	`VARCHAR(128)`	No	PII, Direct identifier
`phone`	`VARCHAR(32)`	No	PII, Direct identifier
`birth_date`	`DATE`	No	PII, Quasi identifier
`last_ip_address`	`VARCHAR(45)`	No	PII, Quasi identifier
`marketing_opt_in`	`BOOLEAN`	Yes	—
`signed_up_at`	`TIMESTAMP`	Yes	—

ShopperAddress — storefront.shopper_addresses · 8 columns

A saved shipping or billing address of a shopper.

Column	Type	Required	Sensitive classes
`location_id` (key)	`BIGINT`	Yes	—
`shopper_id`	`VARCHAR(12)`	Yes	Direct identifier
`usage_type`	`VARCHAR(10)`	Yes	—
`recipient_name`	`VARCHAR(96)`	Yes	PII, Direct identifier
`street_address`	`VARCHAR(128)`	Yes	PII, Quasi identifier
`city`	`VARCHAR(64)`	Yes	Quasi identifier
`postal_code`	`VARCHAR(10)`	No	PII, Quasi identifier
`country_code`	`VARCHAR(2)`	Yes	—

Product — storefront.products · 5 columns

A catalogue product (reference data; invented names).

Column	Type	Required	Sensitive classes
`product_sku` (key)	`VARCHAR(12)`	Yes	—
`product_name`	`VARCHAR(64)`	Yes	—
`category`	`VARCHAR(16)`	Yes	—
`unit_price`	`DECIMAL(10,2)`	Yes	—
`active`	`BOOLEAN`	Yes	—

Cart — storefront.carts · 6 columns

A shopping cart of one session; converted carts become orders.

Column	Type	Required	Sensitive classes
`cart_id` (key)	`BIGINT`	Yes	—
`shopper_id`	`VARCHAR(12)`	Yes	Direct identifier
`device_id`	`VARCHAR(24)`	No	PII, Quasi identifier
`channel`	`VARCHAR(4)`	Yes	—
`status`	`VARCHAR(10)`	Yes	—
`created_at`	`TIMESTAMP`	Yes	—

CartItem — storefront.cart_items · 5 columns

A product placed in a cart.

Column	Type	Required	Sensitive classes
`cart_item_id` (key)	`BIGINT`	Yes	—
`cart_id`	`BIGINT`	Yes	—
`product_sku`	`VARCHAR(12)`	Yes	—
`quantity`	`INT`	Yes	—
`added_at`	`TIMESTAMP`	Yes	—

Review — storefront.reviews · 7 columns

A product review; its free text can contain personal data.

Column	Type	Required	Sensitive classes
`review_id` (key)	`BIGINT`	Yes	—
`shopper_id`	`VARCHAR(12)`	Yes	Direct identifier
`product_sku`	`VARCHAR(12)`	Yes	—
`rating`	`INT`	Yes	—
`reviewer_display_name`	`VARCHAR(64)`	No	PII, Direct identifier
`review_text`	`VARCHAR(2000)`	No	PII, Sensitive
`posted_at`	`TIMESTAMP`	Yes	—

Order — orders.orders · 11 columns

An order placed from a converted cart and shipped to one of the shopper's addresses.

Column	Type	Required	Sensitive classes
`order_number` (key)	`VARCHAR(12)`	Yes	Direct identifier
`shopper_ref`	`VARCHAR(12)`	Yes	Direct identifier
`cart_ref`	`BIGINT`	Yes	—
`shipping_location_ref`	`BIGINT`	Yes	—
`channel`	`VARCHAR(4)`	Yes	—
`status`	`VARCHAR(20)`	Yes	—
`order_total`	`DECIMAL(12,2)`	Yes	Financial
`currency_code`	`VARCHAR(3)`	Yes	—
`promo_code`	`VARCHAR(16)`	No	—
`promo_abuse_flag`	`BOOLEAN`	Yes	—
`placed_at`	`TIMESTAMP`	Yes	—

OrderLine — orders.order_lines · 6 columns

One product line of an order.

Column	Type	Required	Sensitive classes
`line_id` (key)	`BIGINT`	Yes	—
`order_number`	`VARCHAR(12)`	Yes	Direct identifier
`product_sku`	`VARCHAR(12)`	Yes	—
`quantity`	`INT`	Yes	—
`unit_price`	`DECIMAL(10,2)`	Yes	—
`line_total`	`DECIMAL(12,2)`	Yes	—

Payment — orders.payments · 11 columns

A payment attempt for an order (card, wallet or bank transfer).

Column	Type	Required	Sensitive classes
`payment_id` (key)	`BIGINT`	Yes	—
`order_number`	`VARCHAR(12)`	Yes	Direct identifier
`method`	`VARCHAR(14)`	Yes	—
`card_number`	`VARCHAR(19)`	No	Payment, Direct identifier
`card_expiry`	`VARCHAR(5)`	No	Payment
`cardholder_name`	`VARCHAR(96)`	No	PII, Direct identifier
`wallet_iban`	`VARCHAR(34)`	No	Financial, Direct identifier
`amount`	`DECIMAL(12,2)`	Yes	Financial
`status`	`VARCHAR(12)`	Yes	—
`decline_reason`	`VARCHAR(24)`	No	—
`attempted_at`	`TIMESTAMP`	Yes	—

Return — orders.returns · 9 columns

A return and refund of one order line.

Column	Type	Required	Sensitive classes
`return_id` (key)	`BIGINT`	Yes	—
`order_number`	`VARCHAR(12)`	Yes	Direct identifier
`line_ref`	`BIGINT`	Yes	—
`reason`	`VARCHAR(20)`	Yes	—
`status`	`VARCHAR(10)`	Yes	—
`refund_amount`	`DECIMAL(12,2)`	Yes	Financial
`refund_reference`	`VARCHAR(20)`	Yes	Financial, Direct identifier
`customer_comment`	`VARCHAR(400)`	No	PII, Sensitive
`requested_at`	`TIMESTAMP`	Yes	—

Shipment — fulfilment.shipments · 12 columns

A parcel of an order (split orders have several), with its delivery address.

Column	Type	Required	Sensitive classes
`shipment_id` (key)	`BIGINT`	Yes	—
`order_ref`	`VARCHAR(12)`	Yes	Direct identifier
`parcel_index`	`INT`	Yes	—
`tracking_number`	`VARCHAR(20)`	Yes	Direct identifier
`carrier`	`VARCHAR(20)`	Yes	—
`recipient_name`	`VARCHAR(96)`	Yes	PII, Direct identifier
`delivery_street`	`VARCHAR(128)`	Yes	PII, Quasi identifier
`delivery_city`	`VARCHAR(64)`	Yes	Quasi identifier
`delivery_postal_code`	`VARCHAR(10)`	No	PII, Quasi identifier
`status`	`VARCHAR(16)`	Yes	—
`shipped_at`	`TIMESTAMP`	Yes	—
`delivered_at`	`TIMESTAMP`	No	—

LoyaltyAccount — loyalty.loyalty_accounts · 5 columns

A loyalty programme membership with a points balance.

Column	Type	Required	Sensitive classes
`loyalty_id` (key)	`VARCHAR(12)`	Yes	Direct identifier
`shopper_ref`	`VARCHAR(12)`	Yes	Direct identifier
`tier`	`VARCHAR(8)`	Yes	—
`points_balance`	`INT`	Yes	Financial
`enrolled_on`	`DATE`	Yes	—

Compatible connectors

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

Connector	Status with Retail & E-commerce
Local files (Parquet / CSV)	Verified with this pack
PostgreSQL	Verified with this pack
Amazon S3 / S3-compatible storage	Compatible by capability (not yet verified with this pack)
Apache Kafka (connector in preview)	Compatible by capability (not yet verified with this pack)
Azure Blob Storage / Data Lake Storage	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 (connector in preview)	Compatible by capability (not yet verified with this pack)
IBM Db2 (connector in preview)	Compatible by capability (not yet verified with this pack)
Mainframe files (EBCDIC / copybook) (connector in preview)	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 (connector in preview)	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)
Snowflake	Compatible by capability (not yet verified with this pack)
SQLite (developer evaluation) (connector in preview)	Compatible by capability (not yet verified with this pack)

Prerequisites and expected setup effort

You need

This pack is not in any plan yet.
One DataNivra agent inside your network (outbound HTTPS only) that ships Retail & E-commerce 2.0.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 Retail & E-commerce 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

`RET_STRICT`

Every gate; full masking coverage; zero orphaned carts, orders, payments, returns, shipments or loyalty accounts; exact row counts. Default for masked e-commerce 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

`RET_SCENARIO_TESTING`

Every gate, with slightly relaxed NULL-ratio drift for scenario datasets whose business states (abandoned carts, declined payments, undelivered parcels) 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

Activation status

What is missing before you can activate the Retail & E-commerce pack yourself:

no plan includes it yet
the standard agent image does not ship it
the control-plane catalogue does not list it
the hosted sandbox has no synthetic estate for it

Until then, preview it in the browser demo and download its synthetic asset bundle below.

Tell us you need the Retail & E-commerce pack or request a feature for it.

Downloads

Version 2.0.0, 67 files (193.5 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.9 KB · SHA-256 5907e42500c7…
TROUBLESHOOTING.md 4.7 KB · SHA-256 296dda80380f…

Entity–relationship diagram (2)

er-diagram.mmd 4.8 KB · SHA-256 9eaff699d09e…
er-diagram.svg 9.0 KB · SHA-256 ae430e7a73dd…

Sample schemas (5)

schema/entities.json 30.5 KB · SHA-256 4bfe0e5cc64e…
schema/fulfilment.sql 1.1 KB · SHA-256 46bfd6ae924d…
schema/loyalty.sql 708 B · SHA-256 65c5ea3ecf18…
schema/orders.sql 2.7 KB · SHA-256 ce487697a607…
schema/storefront.sql 3.4 KB · SHA-256 a2840cfe984c…

Policy templates (9)

policies/README.md 1.3 KB · SHA-256 f567458d699d…
policies/RET_ANALYTICS_UNLINKED.json 14.9 KB · SHA-256 d39fc0d2dc53…
policies/RET_CARD_DATA_MINIMISED.json 17.1 KB · SHA-256 ac97cabd54ef…
policies/RET_CLASSIFICATION.json 203 B · SHA-256 8496080d3ffe…
policies/RET_LINKED_TEST_DATA.json 17.2 KB · SHA-256 28285d1ca899…
policies/RET_REFRESH_WEEKLY.json 190 B · SHA-256 e54930bed540…
policies/RET_SCENARIO_TESTING.json 549 B · SHA-256 a0728ad1a443…
policies/RET_STRICT.json 549 B · SHA-256 df479db4f4bb…
policies/RET_SUBSET_DEFAULT.json 112 B · SHA-256 d46c49c10d7c…

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

api/curl.sh 2.6 KB · SHA-256 2ccb4492cda1…
api/dataset-request.json 1.5 KB · SHA-256 23d3049aab25…
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 44 B · SHA-256 7a3661779d51…
ci/README.md 499 B · SHA-256 a67c921c86b6…
ci/github-actions.yml 1.9 KB · SHA-256 269b95a20846…
cli.md 1.7 KB · SHA-256 f75ed4ea181c…
sdk_example.py 1.6 KB · SHA-256 1de76064da7f…

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

synthetic/SYNTHETIC_MANIFEST.json 2.7 KB · SHA-256 85a60a99c456…
synthetic/fulfilment.shipments.csv 1.1 KB · SHA-256 408fffed30d3…
synthetic/fulfilment.shipments.json 2.7 KB · SHA-256 715846db94b4…
synthetic/fulfilment.shipments.parquet 4.4 KB · SHA-256 7d55ecc2acce…
synthetic/loyalty.loyalty_accounts.csv 309 B · SHA-256 f9e0eb1481ca…
synthetic/loyalty.loyalty_accounts.json 786 B · SHA-256 5657e7d34456…
synthetic/loyalty.loyalty_accounts.parquet 1.8 KB · SHA-256 358fb1ae4473…
synthetic/orders.order_lines.csv 659 B · SHA-256 f4be27fef1df…
synthetic/orders.order_lines.json 2.2 KB · SHA-256 01a3ba5a5709…
synthetic/orders.order_lines.parquet 2.3 KB · SHA-256 269331d61266…
synthetic/orders.orders.csv 646 B · SHA-256 5cbb02b201bc…
synthetic/orders.orders.json 1.8 KB · SHA-256 5ba3bd2df980…
synthetic/orders.orders.parquet 3.6 KB · SHA-256 92dcd92a070e…
synthetic/orders.payments.csv 787 B · SHA-256 da8e61f2980e…
synthetic/orders.payments.json 2.2 KB · SHA-256 767ed1b69c91…
synthetic/orders.payments.parquet 3.7 KB · SHA-256 f1b5de8eecbb…
synthetic/orders.returns.csv 275 B · SHA-256 d3ddf5a7e704…
synthetic/orders.returns.json 382 B · SHA-256 840d1d39c133…
synthetic/orders.returns.parquet 3.3 KB · SHA-256 c00d0b0f7136…
synthetic/storefront.cart_items.csv 1.2 KB · SHA-256 a56db28718ad…
synthetic/storefront.cart_items.json 4.0 KB · SHA-256 53ba5f1a75b6…
synthetic/storefront.cart_items.parquet 2.3 KB · SHA-256 a5a78cdbbb0b…
synthetic/storefront.carts.csv 899 B · SHA-256 17f86609b77d…
synthetic/storefront.carts.json 2.4 KB · SHA-256 e63c8948f627…
synthetic/storefront.carts.parquet 2.4 KB · SHA-256 fffd9a33a89f…
synthetic/storefront.products.csv 716 B · SHA-256 da8bd52054c5…
synthetic/storefront.products.json 2.2 KB · SHA-256 f005926a9570…
synthetic/storefront.products.parquet 2.0 KB · SHA-256 14ba5ed2b936…
synthetic/storefront.reviews.csv 808 B · SHA-256 25523ab351f7…
synthetic/storefront.reviews.json 1.6 KB · SHA-256 bc9b8030bf4e…
synthetic/storefront.reviews.parquet 3.0 KB · SHA-256 eb46522b9613…
synthetic/storefront.shopper_addresses.csv 818 B · SHA-256 99eb61e596ba…
synthetic/storefront.shopper_addresses.json 2.3 KB · SHA-256 abe5f22a3486…
synthetic/storefront.shopper_addresses.parquet 3.1 KB · SHA-256 0aa5220ab9bb…
synthetic/storefront.shoppers.csv 734 B · SHA-256 a458a103ada6…
synthetic/storefront.shoppers.json 1.7 KB · SHA-256 71d6bfcd5ab3…
synthetic/storefront.shoppers.parquet 3.3 KB · SHA-256 5c7a6272d1d8…

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 Retail & E-commerce 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 Retail & E-commerce pack myself?: This pack is installed and passes DataNivra’s pack conformance kit through the real engine, but it cannot be activated yet: no plan includes it yet, the standard agent image does not ship it, the control-plane catalogue does not list it and the hosted sandbox has no synthetic estate for it. You can explore its synthetic records, masking and scenarios on this page and in the browser demo. Tell us if you need it: demand decides which packs become activatable next.
Which databases and files does the Retail & E-commerce pack work with?: Verified with this pack version: PostgreSQL and Local files (Parquet / CSV). 17 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 Retail & E-commerce 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 Retail & E-commerce pack include?: 10 runnable scenarios (everyday shopping, flash sale peak, abandoned carts, returns and refunds and more), plus 1 negative-test scenario kept apart from valid data.
Do Retail & E-commerce 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

The Retail & E-commerce pack supports privacy and data-minimisation practices by keeping personal data inside your environment; it does not, by itself, establish compliance with any law or regulation.

Try with synthetic data Notify me — tell us you need it

Everything on this page works without an account. Prefer a conversation? Request a demo (optional). Missing something? Request a feature.