Free online SQLITE3 to XML converter

A database import program, archival process, or device may require records in XML instead of a SQLite database file. XML can also expose selected data to systems that cannot open SQLite directly.

What the SQLITE3 format is

.sqlite3 is a commonly used filename extension for a SQLite database. The file is a single serverless database containing tables, indexes, views, triggers, and stored values; mobile applications, browsers, desktop software, and embedded devices frequently create it.

SQLite databases can be opened with the sqlite3 command-line shell, SQLiteStudio, database libraries, and other SQLite management tools. The file is a database, not a document, so conversion normally exports rows and selected schema information rather than reproducing the original database internally.

What the XML format is

XML stores structured data as elements and attributes marked up with text. It is used for data exchange, configuration, document archives, and imports into software that requires XML.

XML has no single standard representation for a relational database. A converter must decide how to represent tables, columns, rows, null values, dates, binary data, and relationships, so two valid converters can produce different XML structures. Check the destination application's required schema before converting.

How to convert a SQLITE3 file to XML

For a conversion without installing software, use the converter on 101convert.com: upload the .sqlite3 file, choose XML as the output format, start the conversion, and download the result. Inspect the output before importing it because the service may use its own table-and-row XML structure.

Convert the complete database with Python

Python's built-in sqlite3 module can read the database, while xml.etree.ElementTree writes well-formed XML. This example exports user tables, preserves null values, and Base64-encodes BLOBs. It requires Python 3.9 or later because it uses ET.indent.

import base64
import sqlite3
import sys
import xml.etree.ElementTree as ET

source, destination = sys.argv[1], sys.argv[2]
connection = sqlite3.connect(f"file:{source}?mode=ro", uri=True)
connection.row_factory = sqlite3.Row
root = ET.Element("database")

for (table_name,) in connection.execute(
    "SELECT name FROM sqlite_master "
    "WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
):
    table = ET.SubElement(root, "table", {"name": table_name})
    escaped_name = table_name.replace('"', '""')
    columns = [
        row[1] for row in connection.execute(
            f'PRAGMA table_info("{escaped_name}")'
        )
    ]
    quoted_name = '"' + escaped_name + '"'

    for record in connection.execute(f"SELECT * FROM {quoted_name}"):
        row_element = ET.SubElement(table, "row")
        for column in columns:
            value = record[column]
            cell = ET.SubElement(row_element, "column", {"name": column})
            if value is None:
                cell.set("null", "true")
            elif isinstance(value, bytes):
                cell.set("encoding", "base64")
                cell.text = base64.b64encode(value).decode("ascii")
            else:
                cell.text = str(value)

ET.indent(root, space="  ")
ET.ElementTree(root).write(destination, encoding="utf-8", xml_declaration=True)
connection.close()

Run it from a terminal with:

python sqlite_to_xml.py input.sqlite3 output.xml

The resulting XML has one table element per user table, one row per record, and one column element per value. The script does not export indexes, views, triggers, foreign-key definitions, or SQLite type declarations.

Export selected records with the SQLite shell

The standard sqlite3 command-line shell can export the result of a query in its XML mode:

sqlite3 input.sqlite3 <<'SQL' > output.xml
.mode xml
.headers on
SELECT * FROM my_table;
SQL

This POSIX-shell example exports only the selected table or query result. Add a WHERE clause to filter records, or replace the query with a join. The heredoc syntax differs in Windows shells; run the three SQLite commands interactively there. This method does not export the complete database schema.

Quality and compatibility limits

• Keep the original database. XML export is not a reversible backup and generally cannot recreate SQLite indexes, triggers, views, constraints, and internal metadata.
• SQLite uses dynamic typing, whereas XML content is usually read as text. A receiving system may need explicit type metadata for integers, real numbers, dates, and strings.
• Foreign keys usually become ordinary column values. Confirm that referenced tables and key columns are exported and that the importer reconstructs relationships.
• SQLite dates are commonly stored as text, numbers, or timestamps rather than as a dedicated date type. Verify the expected date and timezone format.
• BLOB values need a defined representation such as Base64 or hexadecimal. The Python example uses Base64; an importer must decode it.
• XML repeats element names and markup, so large databases can produce substantially larger files than the source. Export only required tables or rows when file size matters.
• XML that is well formed is not necessarily compatible with the target application. Check its required root element, namespaces, element names, encoding, and schema.
• Do not upload confidential or regulated records to an online converter unless its handling and retention terms satisfy your requirements; use the local Python or SQLite-shell method for sensitive data.