What Is the Markdown To INI Converter?

The Markdown To INI Converter on A.Tools transforms Markdown pipe-delimited tables into INI configuration file format. The conversion is automatic — paste your table, edit if needed, and generate key-value pairs ready for .ini files. All processing runs in your browser. No data leaves your device.

INI files are one of the oldest and most widely supported configuration formats. From Windows desktop.ini to Python configparser, from PHP php.ini to Git .gitconfig, the INI format remains a universal standard for application settings.

How to Convert Markdown Tables to INI Format?

Step 1: Provide Your Markdown Data

Click Enter Data to paste a Markdown table into the input area, or click Choose File to drag and drop a .md file. Press Sample to load example data.

Step 2: Edit in the Online Table Editor

Once parsed, an interactive spreadsheet appears. Use the toolbar to:

• Add or delete rows and columns

• Transpose the table (swap rows and columns)

• Remove duplicate rows

• Delete empty rows and columns

• Change text case (UPPERCASE, lowercase, Capitalize)

• Find and replace values — supports case-sensitive search and regex

• Toggle First Row as Header to define field names

Right-click any cell for context-menu operations.

Step 3: Convert and Export

Click Convert to generate INI output. Use Copy to Clipboard or Download File to save as a .ini file.

Key Features

• Two input modes: Paste Markdown directly or upload a .md file via drag-and-drop

• Full table editor: Edit, transpose, deduplicate, find-and-replace before converting

• Automatic conversion: No configuration needed — table columns map directly to INI keys and values

• Client-side processing: Files never leave the browser — zero data upload

• Undo/Redo: Full edit history with revert support

• Context menu: Right-click for quick row/column/cell operations

• Header toggle: Treat the first row as field names or regular data

• Validation indicator: Real-time feedback on input validity

What the Output Looks Like

Two-column table

Given this Markdown input:

| key       | value          |
|-----------|----------------|
| host      | localhost      |
| port      | 8080           |
| debug     | true           |
| log_level | info           |

The converter generates:

host = localhost
port = 8080
debug = true
log_level = info

Three-column table (with sections)

When the table has three columns, the first column becomes the section name, the second becomes the key, and the third becomes the value:

| section    | key       | value          |
|------------|-----------|----------------|
| database   | host      | localhost      |
| database   | port      | 5432           |
| database   | name      | myapp          |
| server     | host      | 0.0.0.0        |
| server     | port      | 8080           |
| server     | debug     | true           |

Output:

[database]
host = localhost
port = 5432
name = myapp

[server]
host = 0.0.0.0
port = 8080
debug = true

With comments

If the first column starts with # or ;, the row is treated as a comment:

| key         | value        |
|-------------|--------------|
| # Database  | settings     |
| db_host     | localhost    |
| db_port     | 3306         |
| ; Cache     | settings     |
| cache_enabled | true       |

Output:

; Database settings
db_host = localhost
db_port = 3306

; Cache settings
cache_enabled = true

Understanding the INI File Format

What is INI?

INI is a plain-text configuration format introduced with Windows 3.x in the early 1990s. Despite its age, it remains one of the most portable and human-readable config formats. An INI file consists of:

• Sections — Headings in square brackets: [section_name]

• Keys and values — Pairs separated by = or :: key = value

• Comments — Lines starting with ; or #: ; this is a comment

INI syntax rules

INI vs other config formats

Limitations of INI

INI is best suited for flat key-value configurations. It does not natively support:

• Nested sections — Only one level of grouping

• Arrays or lists — Values are always strings

• Typed values — Numbers, booleans, and null are all strings

• Multiline values — Each value must be on a single line

For complex configurations, consider using Markdown To TOML or Markdown To YAML instead.

Programs that use INI files

Use Cases: When to Convert Markdown to INI

Python configparser Example

import configparser

config = configparser.ConfigParser()
config.read("settings.ini")

host = config["database"]["host"]
port = config["database"].getint("port")

PHP parse_ini_file Example

$config = parse_ini_file("settings.ini", true);

$host = $config["database"]["host"];
$port = $config["database"]["port"];

Git Config Example

[user]
name = Jane Doee
mail = [email protected]

[core]
editor = vim
autocrlf = false

[push]
default = current

Ansible Configuration Example

[defaults]
inventory = hosts
remote_user = ansible
host_key_checking = False
retry_files_enabled = False

[privilege_escalation]
become = True
become_method = sudo

Frequently Asked Questions (FAQ)

• Does this tool upload my files to a server?

  No. All file parsing and conversion runs in your browser using JavaScript. Your data stays on your device. A.Tools never receives, stores, or transmits your file contents.

• What Markdown table formats are supported?

  The tool supports standard pipe-delimited Markdown tables following the CommonMark specification, including tables with or without leading/trailing pipes and alignment indicators.

• How do table columns map to INI format?

  For a two-column table, the first column becomes the key and the second becomes the value: key = value. For a three-column table, the first column becomes the section name, the second becomes the key, and the third becomes the value: [section] then key = value.

• Can INI files have nested sections?

  No. The INI format supports only one level of sections. For nested configurations, consider using Markdown To TOML or Markdown To YAML instead.

• Does INI support data types?

  No. All values in INI files are plain strings. Parsers like Python's configparser provide methods (.getint(), .getboolean(), .getfloat()) to convert strings to typed values at read time.

• What file extension should I use?

  Use .ini for standard INI files. Some applications use .cfg, .conf, or .config — the format is the same.

• Can I edit the table before converting?

  Yes. After parsing, the full table editor lets you modify cells, add or remove rows and columns, transpose, deduplicate, change text case, and find-and-replace values.

• Is there a file size limit?

  Processing is client-side, so the limit depends on your browser's memory. Tables with tens of thousands of rows work reliably on modern browsers.