Free online YAML to ACCDB converter

What the YAML format is

YAML is a plain-text, indentation-based serialization format used for configuration, structured data exchange, deployment files, and application exports. Programs such as Docker Compose, Kubernetes, Ansible, GitHub Actions, and custom Python or JavaScript applications commonly create or consume YAML files.

A YAML document can contain mappings, lists, nested objects, numbers, dates, booleans, and null values. It has no fixed database schema, so a conversion must decide which mapping becomes a table, which keys become columns, how repeated lists are related, and how nested values are stored.

What the ACCDB format is

ACCDB is the Microsoft Access database format used by Access 2007 and later. It stores tables, relationships, indexes, queries, forms, reports, macros, and VBA modules in one database file.

ACCDB is appropriate when users need relational queries, indexed searches, data-entry forms, reports, or compatibility with Microsoft Access and the Microsoft Access Database Engine. It is less suitable for very large multi-user systems, high-volume concurrent writes, or YAML documents whose structure changes frequently.

How to actually convert YAML to ACCDB

For a quick conversion without installing software, you can use the YAML-to-ACCDB converter on 101convert.com. For repeatable imports, schema control, or nested data, use a local script and the Access Database Engine.

Method 1: import through an intermediate CSV file

1. Open the YAML and identify the record list. A structure such as records: followed by a list is easier to import than a deeply nested document.
2. Convert the list to CSV with a YAML-aware tool or script. Flatten simple fields into columns and serialize nested objects as JSON strings.
3. Open Microsoft Access and choose File → New → Blank database. Save the new file as output.accdb.
4. Choose External Data → New Data Source → From File → Text File, select the CSV, and choose Import the source data into a new table.
5. Set each field's data type, select a primary key, and review the import preview before selecting Finish.

Method 2: create the table with Python

This example handles a top-level YAML list of flat records. It stores nested values as JSON and initially creates every column as long text, which avoids incorrect type inference.

pip install pyyaml pyodbc

Create a blank output.accdb in Access, then run a script similar to this on Windows with the Microsoft Access Database Engine installed:

import json
import yaml
import pyodbc

with open("input.yaml", encoding="utf-8") as f:
    data = yaml.safe_load(f)

if isinstance(data, dict) and isinstance(data.get("records"), list):
    rows = data["records"]
elif isinstance(data, list):
    rows = data
else:
    raise ValueError("Expected a top-level list or a records list")

keys = []
for row in rows:
    if not isinstance(row, dict):
        raise ValueError("Every record must be a mapping")
    for key in row:
        if key not in keys:
            keys.append(key)

def column_name(value):
    return "[" + str(value).replace("]", "]]")[:64] + "]"

connection_string = (
    r"DRIVER={Microsoft Access Driver (*.mdb, *.accdb)};"
    r"DBQ=output.accdb;"
)
cn = pyodbc.connect(connection_string)
cur = cn.cursor()

columns = ", ".join(f"{column_name(k)} LONGTEXT" for k in keys)
cur.execute(f"CREATE TABLE [ImportedData] ({columns})")

names = ", ".join(column_name(k) for k in keys)
marks = ", ".join("?" for _ in keys)
for row in rows:
    values = []
    for key in keys:
        value = row.get(key)
        if isinstance(value, (dict, list)):
            value = json.dumps(value, ensure_ascii=False)
        elif value is not None:
            value = str(value)
        values.append(value)
    cur.execute(f"INSERT INTO [ImportedData] ({names}) VALUES ({marks})", values)

cn.commit()
cn.close()

Run it from the folder containing input.yaml and output.accdb. If the YAML contains multiple entity types, create separate Access tables instead of placing unrelated objects in one table.

Quality, compatibility, and limitations

There is no universal one-to-one mapping from YAML to ACCDB. YAML mappings usually become rows and columns, but nested lists require child tables and foreign keys if they must be queried individually. Storing them as JSON preserves content but prevents normal relational filtering.

The sample script does not infer numeric, date, currency, or Boolean types. After importing, change suitable columns to Access types such as INTEGER, DOUBLE, DATETIME, or YESNO, and add a primary key and indexes. Access has field-name and size restrictions, including a 64-character table or field-name limit; long or duplicate YAML keys should be renamed in a production schema.

Use yaml.safe_load rather than an unsafe YAML loader. Validate the source before import, because malformed indentation, duplicate keys, anchors, custom tags, and implicit date conversions can change or invalidate the resulting values. The Microsoft Access ODBC driver is primarily available on Windows, and its 32-bit or 64-bit architecture must match the Python installation using it.