Convert TSV to TOML

Why Convert TSV to TOML?

Converting TSV data to TOML format transforms flat tab-separated tabular data into a structured configuration format with typed values. While TSV excels at storing raw data from spreadsheets and bioinformatics tools, TOML provides a human-readable, strongly-typed format ideal for configuration files and structured records.

TSV's clipboard-native nature makes it the easiest way to export data from any spreadsheet application. Simply copy cells in Excel or Google Sheets, paste into a text file, and you have clean TSV data. Unlike CSV, there are no quoting issues or delimiter ambiguity. Our converter takes this clean input and produces well-structured TOML using arrays of tables ([[records]]) where each row becomes a named record with properly typed values.

This conversion is particularly valuable when you need to turn spreadsheet data into configuration or seed data for applications built with Rust, Python, or Go. For example, you might maintain a list of server configurations in a spreadsheet, export it as TSV, and convert it to TOML for use in deployment tools. The TOML format preserves data types, making numbers, booleans, and dates explicit rather than storing everything as text.

TSV to TOML conversion bridges the gap between data management in spreadsheets and structured configuration in modern development workflows. The converter automatically detects numeric values, booleans, and dates, producing clean TOML output that follows the v1.0.0 specification.

Key Benefits of Converting TSV to TOML:

• Typed Values: Numbers, booleans, and strings are properly typed in the TOML output
• Clipboard-Native Input: TSV is what you get when copying from Excel or Google Sheets
• No Quoting Hassles: TSV avoids the delimiter conflicts that plague CSV files
• Configuration Ready: Output follows TOML v1.0.0 spec, compatible with Cargo, pyproject, etc.
• Structured Records: Each row becomes a well-defined table entry with named fields
• Human Readable: TOML output is clear, minimal, and easy to edit manually
• Data Integrity: All cell values are preserved with appropriate type conversion
• Modern Ecosystem: TOML is the standard config format for Rust, Python, and Go projects

Practical Examples

Example 1: Application Configuration Seeds

Input TSV file (config.tsv):

service	port	enabled	max_connections
web	8080	true	1000
api	3000	true	500
worker	9090	false	50

Output TOML file (config.toml):

[[records]]
service = "web"
port = 8080
enabled = true
max_connections = 1000

[[records]]
service = "api"
port = 3000
enabled = true
max_connections = 500

[[records]]
service = "worker"
port = 9090
enabled = false
max_connections = 50

Example 2: Package Dependencies

Input TSV file (dependencies.tsv):

name	version	optional	license
serde	1.0.193	false	MIT
tokio	1.35.0	false	MIT
clap	4.4.11	true	Apache-2.0

Output TOML file (dependencies.toml):

[[records]]
name = "serde"
version = "1.0.193"
optional = false
license = "MIT"

[[records]]
name = "tokio"
version = "1.35.0"
optional = false
license = "MIT"

[[records]]
name = "clap"
version = "4.4.11"
optional = true
license = "Apache-2.0"

Example 3: Environment Variables Catalog

Input TSV file (env_vars.tsv):

variable	default_value	required	description
DATABASE_URL	postgres://localhost:5432/app	true	Primary database connection
REDIS_URL	redis://localhost:6379	false	Cache server connection
LOG_LEVEL	info	false	Application log verbosity

Output TOML file (env_vars.toml):

[[records]]
variable = "DATABASE_URL"
default_value = "postgres://localhost:5432/app"
required = true
description = "Primary database connection"

[[records]]
variable = "REDIS_URL"
default_value = "redis://localhost:6379"
required = false
description = "Cache server connection"

[[records]]
variable = "LOG_LEVEL"
default_value = "info"
required = false
description = "Application log verbosity"

Frequently Asked Questions (FAQ)

Q: What is TOML format?

A: TOML (Tom's Obvious, Minimal Language) is a configuration file format created by Tom Preston-Werner (GitHub co-founder) in 2013. It is designed to be easy to read and write, with unambiguous semantics that map directly to hash tables. TOML supports typed values including strings, integers, floats, booleans, dates, arrays, and nested tables. It is the standard configuration format for Rust (Cargo.toml) and Python (pyproject.toml).

Q: Why is TSV better than CSV for this conversion?

A: TSV uses tab characters as delimiters, which virtually never appear in actual data. This eliminates the quoting issues that plague CSV files where commas in cell values require special handling. TSV is also the clipboard-native format, meaning when you copy data from Excel or Google Sheets, the result is tab-separated. This makes TSV inherently simpler and more reliable as a conversion source.

Q: How does the converter handle data types?

A: The converter automatically detects data types in your TSV values. Numbers are converted to TOML integers or floats, "true"/"false" values become TOML booleans, and everything else becomes quoted strings. This type detection ensures that the generated TOML is semantically correct and can be parsed by any TOML library with proper typing.

Q: How are TSV rows represented in TOML?

A: Each TSV row is converted to a TOML array of tables entry using the [[records]] syntax. The header row provides the key names, and each subsequent row becomes a separate [[records]] block with key-value pairs. This is the idiomatic way to represent tabular data in TOML.

Q: Can I use the output with Cargo or pyproject.toml?

A: The generated TOML follows the TOML v1.0.0 specification and is valid for any TOML parser. However, the output structure uses generic [[records]] tables. For Cargo.toml or pyproject.toml, you may need to adjust the table names and structure to match the expected schema. The converter provides a solid starting point that you can customize.

Q: Is TSV the same as what I get when copying from Excel?

A: Yes! When you select cells in Excel, Google Sheets, or LibreOffice Calc and copy them to the clipboard, the data is stored in TSV format (tab-separated values). You can paste this into a text editor, save it as a .tsv file, and convert it directly. This makes TSV the most natural format for spreadsheet-to-configuration workflows.

Q: What happens with empty cells in TSV?

A: Empty cells in your TSV file are converted to empty strings ("") in the TOML output. If a column consistently contains numeric values but has empty cells, those empty cells will still be represented as empty strings rather than null or zero, preserving the distinction between missing and zero values.

Q: Can I convert large TSV files to TOML?

A: Yes, the converter handles large TSV files efficiently. However, TOML is primarily designed for configuration files, not large datasets. For TSV files with thousands of rows, the resulting TOML file will be quite verbose since each row becomes a multi-line table entry. For very large datasets, consider JSON or YAML as alternative target formats.