JSON Lines (JSONL) to Log Converter

Structured logging produces JSON Lines — a single JSON object per line, one of the most common shapes for application and service logs (Node, Python, Go, Bunyan, Pino, structlog and most log shippers can all emit it). Machines love it; the human eye does not, especially when you are scrolling a terminal at 2am trying to find the one line that matters. JSONL to Log Converter turns those records back into readable log text with a layout you choose, entirely client-side.

Pick key=value pairs for a compact, complete line where every field from every record is visible (values containing spaces, an = sign, or a quote are automatically wrapped in quotes and escaped so the line still parses as tokens), a timestamp + level + message format that reads like a classic application log with any remaining fields appended in parentheses, or write a fully custom template using {placeholder} tokens that resolve against each record — including nested paths like {user.id} or {db.host} for values buried inside nested objects.

Time, level and message fields are auto-detected across common naming conventions — ts/time/timestamp/@timestamp/datetime/date for time, level/severity/loglevel/log_level/priority for level, message/msg/event/text/detail/log for the text — checked case-insensitively so a field named Level or MESSAGE is still recognized. Once a field is used for timestamp, level or message, it will not also show up as a duplicate in the remaining-fields list, so the timestamp+level layout stays clean instead of repeating data. Timestamps can stay exactly as they arrived, or be normalized to ISO 8601 UTC or Unix milliseconds so records from different sources sort and compare consistently. Nested objects and arrays are printed as compact inline JSON rather than being flattened or dropped, so no information is lost in the conversion. Everything runs locally in your browser — paste JSONL, pick a layout, convert, and nothing is ever sent to a server.

• JSONL parsing: one record per line, tolerant of surrounding whitespace and blank lines.
• Three layouts: key=value, timestamp+level+message, or a fully custom template.
• Custom templates: {field} tokens with dotted paths like {user.id} for nested values.
• Auto-detect: time, level and message fields matched by common names, case-insensitively.
• No duplicate fields: a field used for timestamp/level/message is never repeated in the leftover-fields list.
• Timestamp control: raw, ISO 8601, or Unix milliseconds.
• Nested values: objects and arrays printed as compact JSON, never silently dropped.
• Safe key=value quoting: values with spaces, quotes or an equals sign are quoted and escaped.
• Missing handling: configurable placeholder text for absent fields in custom templates.
• Skip reporting: lines that are not valid JSON objects are counted and listed, not silently ignored.
• Sample data: realistic JSONL records in one click.
• Local processing: nothing is uploaded, nothing stored.

1. Paste JSONL. Drop one JSON object per line into the input box, or click Load sample to see a working example immediately.
2. Pick a layout. key=value for completeness, timestamp+level+message for a familiar log look, or custom template for your own format.
3. Configure. Set the timestamp shape (raw / ISO 8601 / Unix ms), and for custom templates, edit your {field} tokens and the missing-value placeholder.
4. Convert. Readable log lines appear immediately, along with record and byte counts.
5. Check for skipped lines. Any line that failed to parse as a JSON object is reported in a warning with its line number.
6. Copy or download. Copy to clipboard, download as a .log file, or use Save PDF to print — done.

Example 1 — Quick triage. Run JSONL from a Node or Python logger through the timestamp + level layout to scan a busy stream at a glance: [2026-08-15T10:30:01Z] ERROR Database connection timeout (service=auth, retries=3, db={"host":"db-01","port":5432}).

Example 2 — Ops dashboards. Use a custom template like {ts} {level} [{service}] {message} to match how your on-call tooling already formats logs, dropping fields you do not need to see.

Example 3 — Review boards. Paste JSONL into key=value mode and paste the result into a ticket — every field stays visible and readable, with multi-word messages safely quoted.

Example 4 — Security audit. Template out only {ts} {ip} {action} for a clean, redacted audit trail from structured auth events, ignoring everything else in the record.

Example 5 — Regression fixture. Reformat structured test output into the exact text your assertions expect, without hand-writing log strings in test code.

Example 6 — Nested config values. A record like {"ts":"...","event":"db.error","db":{"host":"db-01","port":5432}} lets you pull just {db.host} into a custom template instead of dumping the whole nested object.

• Human-friendly: structured records become readable, scannable lines.
• Layout freedom: fixed formats or your own template with nested-path support.
• Zero field-picking: common time/level/message names detected automatically, case-insensitively.
• No data loss: nested values stay valid JSON and leftover fields are always shown, never silently dropped.
• Parseable output: key=value lines quote and escape values so they survive a second parse.
• Bad input surfaces: unparseable lines are counted and listed by line number instead of vanishing.
• Private by design: processed locally, never uploaded.