Clean-room engine · reads Oracle artefacts at the byte level · v4.16.0 GA · contains no Oracle software
Capabilities Evidence Contact
reclaimDB · block-level Oracle extraction

Extract Oracle data without the database.

Source — not output — is what makes the difference. reclaimDB reads Oracle datafiles, Data Pump dumps and RMAN backups straight off disk and rebuilds your tables byte-for-byte. It works exactly where SQL-based tools structurally cannot.

Request evaluation → See what it does
✕ live instance no running DB ✕ Oracle license no SE/EE keys ✕ network path air-gapped OK
RECLAIMDB · BYTE-EXACT ENGINESRC 0x2000
DATAFILE DECODE TABLE RAW BLOCKS · UNORDEREDREASSEMBLED · BYTE-EXACT ✓ BLOCK 0x2000 · ROW 0
15open formats
28+Oracle data types
11.2 → 26aiversions covered
502/0strict tests pass / fail
byte·exactverified in CI
// Capabilities

Six ways to reclaim your data.

One byte-exact engine, six jobs it was built for. Pick the one that matches what you have — a dump, a datafile, a corrupt instance, a backup piece, a single record an auditor needs, or a storage snapshot you want kept in an open format.

MODULE 01SRC · *.dbf
BLOCK 0x2000 · BYTE-EXACT
Core engine reclaimDB · dbf-extract

Read datafiles. No instance.

Open Oracle .dbf datafiles straight off disk and rebuild every table — block by block — with no running database, no license and no SQL layer in between.

  • Block-level decode of BASIC & OLTP compression, row chaining and partitions
  • Offline TDE decryption: wallet → master key → AES-256, fails closed on the wrong key
  • Autoscan via SYSTEM tablespace; point-in-time with redo / archive-log apply (--as-of SCN)
How it works →
MODULE 02SRC · *.dmp
MAGIC 0x2815 · GA
GA · v4.16 reclaimDB · dmp-extract

Read Oracle dumps. Without Oracle.

Parse Data Pump .dmp files directly from disk. Tables, LOBs and embedded documents land in open formats — no import, no running database, no Oracle code on the box.

  • 28+ Oracle data types incl. JSON, VECTOR, BOOLEAN (23ai+), TIMESTAMP LTZ
  • LOB side-file extraction: 25+ magic-byte signatures, SHA-256 manifest
  • BASIC / OLTP decoded · native OSON (26ai) byte-exact · HCC best-effort
How it works →
MODULE 03SRC · corrupt
SHA-256 · SEALED
Capability use case · forensics & DR

When the instance won't start.

Pull intact records out of a crashed, corrupted or powered-off database — and prove they weren't touched. Post-mortem extraction with evidence integrity built in.

  • Salvage from damaged blocks a normal import would reject — recovered, not guessed
  • Per-file / per-LOB SHA-256 sealing + manifest for chain-of-custody
  • Read straight from ASM raw devices and offline volumes
How it works →
MODULE 04SRC · RMAN piece
512B BLOCKS · OPEN
Capability · RMAN beta use case · backup access

Open the closed backup.

RMAN backup pieces are a sealed, proprietary format. reclaimDB reads them at the byte level — so you can answer "are these backups actually restorable?" without a target database to restore into.

  • Decode RMAN backup pieces directly — no catalog, no target instance
  • Validate readability on a schedule — before you ever need the restore
  • Turn a proprietary container into 15 open, portable formats
How it works →
MODULE 05SRC · archive
LOCK-ON · 1 RECORD
Capability use case · audit access

One record. Pulled fast.

An auditor needs a single row that left the live database years ago. Point reclaimDB at the backup or dump and retrieve exactly that record — without rebuilding the whole environment.

  • Targeted lookup against cold backups and archived dumps
  • No full restore, no staging instance to stand up first
  • Answer an audit or eDiscovery request in minutes, not days
How it works →
MODULE 06SRC · snapshot
SNAPSHOT · OPEN
Capability · storage-native use case · open archive

Snapshot in. Open archive out.

Run it against an application-consistent storage snapshot or clone — never the live database. Every table lands in open CSV, Parquet, Avro or Delta: no production load, no second Oracle license, and a copy that stays readable for decades.

  • Reads off SnapMirror, SRDF, ZFS or EBS snapshots — straight from the storage replica, fully off-host
  • No session, no listener, no load on production — and no Oracle license to read it
  • Scheduled export to 15 open formats — a license- and version-independent archive built to outlive Oracle
How it works →
// The pipeline

Source → engine → open formats.

Every path runs through the same byte-exact engine. It reads the raw on-disk artefact, decodes and decrypts it, reassembles the rows, and verifies the result before a single byte is written out.

RECLAIMDB · BYTE-EXACT ENGINESRC *.DBF · DECODE BLOCK 0x2000
Datafile *.dbf · block 0x2000 Data Pump *.dmp · magic 0x2815 RMAN piece 512-byte blocks Snapshot ASM · EBS · SnapMirror ENGINE CORE 01 decode 02 decrypt 03 reassemble 04 verify byte-exact · SHA-256 sealed SOURCES · NO ORACLE REQUIRED ENGINE VERIFIED OUTPUT
// 15 open formats CSVJSONNDJSONXMLSQLSQL*Loader PostgreSQLSQLiteXLSX ParquetAvroORCArrowDeltaIceberg
Sources · no Oracle required
Data Pump .dmp Datafiles .dbf RMAN backup pieces ASM raw / snapshots
reclaimDB engine
01decode
02decrypt
03reassemble
04verify
15 open formats · byte-exact
CSVJSONNDJSONXMLSQLSQL*Loader PostgreSQLSQLiteXLSX ParquetAvroORCArrowDeltaIceberg
// Runs in isolation

Nothing in. Nothing out.

reclaimDB is a single, performance-optimized CLI binary. It runs entirely on the isolated host where your data sits — air-gapped, with no live instance, no Oracle client and no network path. Nothing phones home, nothing is uploaded.

Single static binary

One self-contained executable — no runtime, no Oracle client, no install footprint. Drop it on the host and run.

Air-gapped by design

Runs on a fully isolated, offline host: zero ingress, zero egress, no telemetry, no license call-home. The data never leaves the machine.

Built for automation

Drive it from cron, Ansible or CI — even across a data diode. Deterministic exit codes and structured output make it pipeline-ready.

// Evidence

What it handles — and what it won't.

Every claim here is backed by a CI gate or a measurement from a real Oracle source container — not a synthetic fixture. And we publish the limits: knowing what reclaimDB refuses is more useful than pretending it does everything.

Supported

Verified & in scope

GA— regression-verified in CI
+Metadata auto-detect from SYSTEM.dbf
+Row chaining & migration resolve · block-level corruption resilience
+Multi-threaded byte-exact export --parallel
+DMP extract — 13 writers · LOB chaining (inline + OOR) · side-file w/ SHA-256 manifest
+BASIC & OLTP compression · SecureFile inline LOBs incl. COMPRESS LOW (clean-room LZO1X)
+Consistency certificate — Stop-SCN + fuzzy-bit per datafile, tiered verdicts, chain-of-custody (18c–26ai; 11g partial)
+TDE wallet (PKCS#12, AES-128/192/256) + raw key — a missing key loses rows loudly, never silently
+RMAN backup-piece parsing (plain, encrypted, compressed) · backup catalog
+15 open export formats · 28+ data types (JSON/OSON, VECTOR, BOOLEAN) · Oracle 11.2 / 12.2 / 19c / 26ai
Beta— functional, limited coverage
+Datafile recovery .dbf — OLTP-scale, 512M-row restores verified (19c / 26ai)
+TDE auto-login cwallet.sso · type inference without metadata (--require-metadata refuses the fallback)
+RMAN password / dual-mode decryption — unverifiable blocks excluded loudly, non-zero exit
+RMAN incremental merge (L0 + L1) — DBID mismatch refused · ZSTD MEDIUM decompression
+ASM disk scanning
+Point-in-time recovery — redo parse · INSERT/UPDATE/DELETE apply · gap detect
+DBF LOB out-of-row · index-organized tables (IOT) · OBJECT / VARRAY / NESTED / SDO_GEOMETRY (dmp-extract, 19c)
Experimental— implemented, not CI-validated
+HCC (Hybrid Columnar) — env-gated RECLAIMDB_ALLOW_HCC=1
+KGC compression (DMP, env-gated) — RMAN KGC pieces hard-refused
+ASM file extraction — synthetic fixture
+Classic exp / imp dumps (Oracle 7–11g) — auto-detected
Refused / out‑of‑scope

Won't touch — by design

Refused— structured OL_REFUSE_* marker
✕OL_REFUSE_LONG_WRITE LONG / LONG RAW → dmp-extract (19c) only — DBF path fail-closed
✕OL_REFUSE_JSON_NATIVE_PRE_21C pre-21c native JSON — format-impossible
✕OL_REFUSE_COLUMN_ENCRYPTED column-level ENCRYPT USING → use tablespace TDE
✕OL_REFUSE_CHARSET_OUT_OF_SCOPE IW8 / TR8 / AR8 MSWIN → AL32UTF8
Not supported— permanent scope-out
○DMP password encryption — proprietary KDF → re-export ENCRYPTION=NONE
○DMP wallet block-cipher (Transparent / Dual, e2e) — key not derivable (clean-room)
○RMAN backup-piece TDE / transparent mode — no wallet-derived key path
○ANYDATA · REF
○External & Temporary tables
// Honest by construction — every refusal emits a structured OL_REFUSE_* marker and fails closed. No silent mis-decode.

Your data. Reclaimed.

Tell us about your source — a dump file, a datafile, an RMAN backup piece, a storage snapshot — and we'll send back a signed evaluation binary, a sample report, and a candid read on which paths apply to your case.

Request evaluation → Compare capabilities