Export Notes content to SQL or Excel

• Lialis Notes2SQL requires a IBM HCL Domino server version 9 (or higher).
• The Domino server must run on a Windows 2012 server (or higher).
• For configuration of the Notes2SQL tool you need a Notes client version 9 (or higher).
• SQL server, for example Microsoft SQL Express or SQL Server Developer.
• Microsoft Excel does not have to be installed on the migration server in the case of Notes database exports to Excel.
• Microsoft SQL Server Management Studio is required.
• It’s recommended not to run SQL Server on the same Windows server that hosts the Domino server.

Introduction

The image below gives a schematic overview of how our Notes2SQL software migrates Lotus Notes to SQL Server. As an example only a few Notes field types are displayed in this image. However, our tool supports all Notes field types.

Notes database content analyzes

Lialis Notes2SQL first analyzes the Notes database to gather information about all fields in each document. In Notes, documents using the same form (e.g., ABCDE) can have more, fewer, or different fields than those defined in the form itself. This happens because of dynamic subforms and flexible field definitions or agents or other tools adding fields to the Notes documents. Therefore, we can’t rely solely on the form design to determine which fields need to be migrated to SQL.

The image below displays the details of an analyzed Notes database. You can see the smallest and largest documents, as well as the forms found in the Notes database.

Each form contains details about the fields found in all Notes documents within the database that use that specific form. For example:

TWDocId;TWDocId;1534;nvarchar(98);0;49;TEXT(1534)
TWDocName;TWDocName;1534;nvarchar(26);0;13;TEXT(1534)
Form;Form;1534;nvarchar(26);0;13;TEXT(1534)
ComposedDate;ComposedDate;1534;datetime2;0;10;DATETIMES(1534)
From;_From;1534;nvarchar(70);0;35;TEXT(1534)
OriginalUnid;OriginalUnid;846;nvarchar(68);0;34;TEXT(846)

Explanation:

TWDocId → Notes field name
TWDocId → SQL column name
1534 → number of Notes documents containing this field
nvarchar(98) → SQL data type chosen (text, max 98 chars)
0 → number of empty values
49 → average or max string length (depends on export config)
TEXT(1534) → field content type (text) and again the document count

This summarizes, for each field: its name, data type, how often it occurs, and its storage definition in the generated SQL table.

Purpose of Collecting Field Information

Lotus Notes forms are often inconsistent — documents using the same form can contain different sets of fields.
To create a reliable SQL database structure, the analysis collects detailed information about every field found in all Notes documents.

This information allows us to:

• Identify which fields actually exist in the database.

• Determine how frequently each field occurs.

• Define the correct SQL column types and sizes.

• Detect unused or rarely used fields that can be excluded.

• Ensure the generated SQL schema accurately reflects the real Notes data, not just the form design.

In short, this step guarantees that the SQL database structure fully matches the content of the Notes database.

SQL Database Creation

When the analysis is complete, Lialis Notes2SQL automatically creates the SQL database.
For each Notes form, a separate SQL table is generated. For each field found during the analysis, corresponding columns are created with the exact data types and sizes determined from the Notes data.

This ensures that the full content of the Notes database can be accurately migrated into the SQL tables in the subsequent migration step.

Content Migration

The content migration and all related tasks are executed by the Domino Server Agent Manager.
Because the Agent Manager enforces a maximum run time (for example, 24 hours), Lialis Notes2SQL is designed to handle this limitation automatically. Before the Domino server stops the running migration agent, Notes2SQL safely ends the current migration cycle. During the next run, it resumes exactly where it left off. This mechanism allows very large Notes databases — even those containing millions of documents — to be migrated reliably on the Domino server.

Update Runs

After the initial full migration, Lialis Notes2SQL can perform update runs to keep the SQL database synchronized with the Notes database.

During an update run, the tool detects:

• Modified documents — updates existing SQL records with the latest data.

• New documents — inserts new records into the SQL tables.

• Deleted documents — removes the corresponding records from SQL.

This incremental update process allows you to refresh the SQL database regularly without re-migrating all documents, ensuring that the SQL data remains consistent with the live Notes database.

Migration Log Example

Below is an example of a complete migration log. For clarity, some lines have been removed, and the example focuses on the main topics.

2025/10/15 17:05:45; Database analysis: DB-Alpha
2025/10/15 17:05:45; Form added: Form A
2025/10/15 17:08:10; Form added: Form B
2025/10/15 17:05:48; 1000/38221 documents analyzed
2025/10/15 17:06:34; 10000/38221 documents analyzed
2025/10/15 17:07:25; 16000/38221 documents analyzed
2025/10/15 17:12:33; 37000/38221 documents analyzed
2025/10/15 17:12:57; 38221/38221 documents analyzed
2025/10/15 17:12:57; Analysis done
2025/10/15 17:12:57; Updating statistics and creating forms
2025/10/15 17:12:57; Statistics updated and forms created
2025/10/15 17:12:57; Database analysis task done
2025/10/15 17:20:44; Mapping database: DB-Alpha
2025/10/15 17:20:44; Mapping form: Form A
2025/10/15 17:20:44; Mapping form: Form B
2025/10/15 17:37:44; Initialising SQL
2025/10/15 17:37:45; Creating database: SQL-Alpha
2025/10/15 17:38:35; Table created: FormA
2025/10/15 17:38:35; Table created: FormB
2025/10/15 17:38:35; Initialisation done
2025/10/15 17:48:46; Conversion start
2025/10/15 19:02:01; 100 documents processed
2025/10/15 19:03:50; 1000 documents processed
2025/10/15 19:07:52; 3000 documents processed
2025/10/15 20:29:14; 37300 documents processed
2025/10/15 20:32:21; 38221 documents processed; 38221 documents updated
2025/10/15 20:32:21; Start processing of deletion stubs
2025/10/15 20:32:22; 0 deletion stubs processed
2025/10/15 20:32:22; 0 records deleted
2025/10/15 20:32:22; Database converted
2025/10/15 20:32:22; Conversion done

Content-Only Conversion

Lialis Notes2SQL focuses exclusively on data migration — it converts the content of Notes documents to SQL tables.

The software does not convert or interpret the Notes application design (forms, views, agents, scripts, etc.).
Only the data stored in the documents — including text fields, dates, numbers, and rich text (text, images, attachments) — is analyzed and migrated to SQL.

If you also need to analyze or convert the Notes code base, that requires separate tooling designed for Notes design or DXL export.

Notes rich text fields

A Notes document can contain attachments, images, links, text, and other rich text content in one or more rich text fields. Since a Notes rich text field can hold multiple files with the same name, a file like document.docx may appear several times across different fields. To prevent “file already exists” errors during migration, all content from each rich text field is exported as a single MIME data set. The rich text field is then stored in SQL as MIME data within a dedicated SQL field (see image below).

Exporting the rich text content (text, images and files) to disk.

Requirements

Powershell 7.5.1

Mimekit from NuGet

Powershell script example

# Load MimeKit assembly
Add-Type -Path "E:\mimekit\lib\netstandard2.0\MimeKit.dll"

$Server = ".\SQLserver"
$Database = "Notesexampledb"
$Dest = "E:\Export\"

# Query the DB
$query = "SELECT universalid, description FROM dbo.bookmark"
$conn = New-Object System.Data.SqlClient.SqlConnection
$conn.ConnectionString = "Server=$Server;Database=$Database;Integrated Security=True;"
$conn.Open()

$cmd = $conn.CreateCommand()
$cmd.CommandText = $query
$reader = $cmd.ExecuteReader()

while ($reader.Read()) {
$id = $reader["universalid"]
$desc = $reader["description"]

$folder = Join-Path $Dest $id
if (!(Test-Path $folder)) {
New-Item -ItemType Directory -Path $folder | Out-Null
}

$emlPath = Join-Path $folder "message.eml"
$textFile = Join-Path $folder "message.txt"
$imageFolder = Join-Path $folder "images"
if (!(Test-Path $imageFolder)) {
New-Item -ItemType Directory -Path $imageFolder | Out-Null
}

try {
# Save EML file
[System.IO.File]::WriteAllText($emlPath, $desc)
Write-Output "EML opgeslagen: $emlPath"

# Load EML with MimeKit
$stream = [System.IO.File]::OpenRead($emlPath)
$email = [MimeKit.MimeMessage]::Load($stream)
$stream.Close()

# Extract and save body text
$emailBody = $email.TextBody
$emailBody | Out-File $textFile -Encoding UTF8
Write-Output "Text content opgeslagen: $textFile"

# Extract and save attachments
foreach ($attachment in $email.Attachments) {
$fileName = $attachment.ContentDisposition?.FileName
if (-not $fileName) { $fileName = $attachment.ContentType.Name }
if (-not $fileName) { continue }

$attachmentPath = if ($fileName -match "\.jpg$|\.png$|\.gif$|\.jpeg$") {
Join-Path $imageFolder $fileName
} else {
Join-Path $folder $fileName
}

$fileStream = [System.IO.File]::Create($attachmentPath)
$attachment.Content.DecodeTo($fileStream)
$fileStream.Close()
Write-Output "Attachment saved: $attachmentPath"
}

} catch {
Write-Output ("Error processing {0}: {1}" -f $id, $_.Exception.Message)
}
}

$conn.Close()

High-Level Migration Setup

It is recommended to set up a dedicated Domino server (see prerequisites) to run the Lialis Notes2SQL software, which itself is a Notes application.

Replicate the Notes databases from the production server to this dedicated migration server using push-only replication. Grant the Domino server running the Lialis tooling Reader access to all databases, including all ACL roles.

This setup ensures that the migration process does not affect the production environment.
Schedule regular replication — for example, once per week — from the production server to the migration server. This allows Notes2SQL update runs to execute smoothly and keep the SQL databases up to date.

Preparations

Make sure your Notes client has this Notes.ini setting: JavaMaxHeapSize=512mb

Make sure the Domino server has below Notes.ini settings present:

HTTPJVMMAXHEAPSIZE=256M
HTTPJVMMAXHEAPSIZESET=1

Store a copy of the Notes2SQL software (LNXtract.nsf) on the Domino server (R85 or higher).

Subsequently, sign it with the Domino server ID and set the ACL properly (Domino server and Domino admin must have manager access with delete and the role Admin attached).

The Notes2SQL conversion agent needs at least “Sign or run restricted LotusScript/Java agents” access on the Domino server. Therefore the Notes2SQL NSF must be signed with a Notes ID that has this access.

The agent may run for a long time depending on the size of the database that you convert. We advise to have the “Max LotusScript/Java execution time” set at at least 6 hours.

Configuration of the Notes2SQL software

Choose Add license to add the Lialis license key we will provide you after you have purchased the software.

Leave it empty if you only want to evaluate the software. Please note that an conversion limit is applicable in this evaluation version.

Then click the big red button to start the IBM Domino conversion background agent for the conversion of the Notes content to SQL. After clicking, the button will turn to green.

Subsequently, select General Settings to configure the SQL server connections. Notes2SQL only supports Microsoft SQL server over OLEDB protocol.
To connect to the SQL database it requires the connection IP address to the SQL server and login credentials of a user with SQL database administration privileges.

The test connection will reply an error if it cant reach the Domino server, if there is no message the connection is OK.

Once this is done please click Add Notes Application to choose the Notes NSF file you wish to convert to SQL

Then select the Notes database and press Start Application Analysis

The Domino server will automatically take care of the Notes to SQL migration duties.

You complete the preparations when the status changes to “Fields mapped“. This basically means that the Notes2SQL field mappings for all forms in the Notes database are in place.

At this stage in the process you are almost ready to start the conversion. Next in line is to click Start SQL Initialization to create an empty SQL database with all the required tables and columns.

After a few minutes an empty SQL database has been created by the Domino server as you can see below.

Finally, click Start conversion to send the Notes content to the SQL database. The Domino server will execute this action.

Conversion Modes

Lialis Notes2SQL offers two ways to perform the content conversion:

1. Start Conversion Once – Executes a single full conversion run.
   Use this option when you want to migrate the Notes database content to SQL only once.

2. Start Conversion – Performs a complete initial conversion and automatically continues with regular update runs.
   This mode keeps the SQL database synchronized with the Notes database by processing newly added, modified, and deleted documents.

Performance

It is possible to create multiple instances of the Lialis Notes2SQL nsf application (for example, Notes2SQL1.nsf, Notes2SQL2.nsf, etc.) on the Domino migration server. This allows you to run migrations in parallel, provided your Domino server has enough Agent Manager threads available to execute multiple agents simultaneously.

Analysis Speed

The analysis phase often takes longer than the actual content migration. In large projects, we have encountered Notes databases containing millions of documents and thousands of fields per document. In such extreme cases, the analysis may take several weeks to complete.

For typical Notes databases — with a few thousand documents and a moderate number of fields — the analysis is usually finished within one to two days.

Migration Speed

Content migration speed depends mainly on:

• The number of fields per document (each field must be written to SQL).

• The performance of the Domino and SQL servers.

• The network connection between the servers.

On average, you can expect a migration rate of around 20,000 documents per day.

Summary

Migration speed varies greatly depending on the database size, structure, and server performance.
While large databases may take considerable time, Lialis Notes2SQL provides reliable and resumable migration runs to handle even very large datasets efficiently.

Expert Support for Complex Notes Migrations

Every Domino environment is different — and every Notes database holds its own surprises. During migrations, unexpected data structures, hidden fields, or design inconsistencies often appear. That’s why we don’t just deliver software — we deliver expertise.

Our team consists of highly experienced Domino administrators and developers who have handled countless migration projects. They understand the technical and practical challenges that come with large-scale Notes environments and know how to solve them quickly.

When issues arise, we can adapt and extend our tooling to handle special cases, ensuring that the migration process continues smoothly and successfully.

Whether your project involves a few databases or thousands, our specialists can guide, troubleshoot, and fine-tune the migration — making sure your data arrives in SQL exactly as expected.