Why named groups for log parsing?

Named groups make the output table self-documenting — (? ...) becomes the timestamp column. Without them you would get group_1, group_2 and have to remember what each position means.

What if a line does not match?

Lines that fail the regex are reported separately so you can refine the pattern or filter them out. The successful matches still produce a usable table.

Is log data uploaded?

No. Lines are parsed in your browser using the native RegExp engine. Nothing is sent to a server.

named groups · csv table · multi-line

Parse log lines with a named-group regex

Write one pattern, drop many lines, get a structured table you can copy or export as CSV. Runs locally.

Log Line Parser

Lines

input

Matched

parsed

Failed

no match

Columns

named

input · pattern + lines

Pattern (named groups)

Log lines

output · parsed table

#	ip	user	time	method	path	status	bytes
1	127.0.0.1	alice	18/May/2026:10:00:01	GET	/index.html	200	1234
2	10.0.0.5	bob	18/May/2026:10:00:02	POST	/api/login	401	89
3	192.168.1.7	-	18/May/2026:10:00:03	GET	/static/app.css	304	0

Quick Start

How to parse log lines with regex

Write a named-group regex once, paste many log lines, get a structured table you can export as CSV.

01
Write a pattern
Use (?<name>...) to label each field. Names become CSV columns.
Patterns compile through the JavaScript RegExp constructor, so syntax errors surface immediately and engine quirks like Unicode property escapes (\p{L}) work when the u flag is on.
patternECMAScriptliterallive
input · literalregex · regex
(?<ip>\S+).*(?<status>\d+)
loaded · ECMAScriptPCRE · ready
02
Paste lines
Drop your raw logs. Each line is matched independently.
Each flag character mirrors the ECMAScript literal: g enables iteration, i folds case, m anchors per line, s lets . match newlines, u unlocks proper Unicode, y is sticky, and d emits indices.
flagsoptionsg · i · mlive
config · optionslines · flags
127.0.0.1 - … 200
flags applied · liveECMA · live
03
Read the table
Captured groups appear as columns. Unmatched lines are highlighted.
Watch for catastrophic backtracking on nested quantifiers — a common ReDoS source. The tool caps match counts to keep the page responsive on pathological patterns.
matchgroupshighlightReDoS-safe
run · outputcsv · matches
ip status 127.0.0.1 200
matches · livegroups · live
04
Copy or export
Grab the output as JSON, CSV, or plain text — ready for your editor or pipeline.
Copy writes via navigator.clipboard.writeText; downloads use a Blob and object URL, so nothing transits the network and the output is byte-identical to what you see on screen.
copyexportclipboardblob
export · exportedready · saved
Copied
ready to shipsuccess

Pro tips

Regex patterns that don't melt down

Use named groups

(?<year>\d{4}) reads better than $1 and survives reordering. Supported in ECMAScript 2018+.

Anchor strictly

Use ^/$ with the m flag when matching whole lines. Without anchors, partial matches sneak through.

Avoid catastrophic backtracking

Nested quantifiers like (a+)+ can explode. Run patterns through ReDoS Detector first.

Escape every literal

Backslash any meta character you want literally: \.\$\^\*\+\?\[\]\{\}\|\\.

Test edge cases

Empty string, single character, unicode, the maximum length you expect — write fixtures for each.

Patterns aren’t parsers

Don’t parse HTML, JSON, or balanced parens with regex. Use a proper parser when the grammar is recursive.

Use Cases

When to parse logs

One-off analysis without writing a script.

Ad-hoc log analysis

Turn raw logs into a structured CSV in seconds. Compiles through the JavaScript RegExp constructor — engine quirks (Unicode property escapes, sticky matching, named groups) work when their flags are on. Error messages cite the exact position of any syntax issue.

ReDoS-safe

Custom formats

Match a bespoke log format your tools don't. Pairs with the ReDoS detector to catch catastrophic backtracking before you deploy. A pattern that handles 1k-character input fine can become a denial-of-service vector on attacker-controlled 1M-character input.

ECMA-compliant

ETL prototype

Sketch a parser before scripting. Output exports as JavaScript, Python re, Java util.regex, .NET System.Text.RegularExpressions, PCRE, and POSIX — language quirks are highlighted on conversion so you don't ship a JS-only pattern to a Go service.

spec-grade

Incident response

Pull out just the IPs and status codes you need. Capture groups (named or numbered) round-trip cleanly into replacement strings, JSON output, or CSV extraction without re-typing. Backreferences ($1, ${name}) preserve semantics across languages.

cross-engine

Teach regex

Named groups make logs concrete teaching material. Test against edge cases — empty input, single character, max length, multibyte boundaries — to catch off-by-one and zero-length match bugs before they reach production.

test-ready

Audit a format

Spot lines that don't fit the expected shape. All matching runs client-side so secret patterns never leave the browser. Useful when the pattern itself is sensitive (PII regexes, internal data formats, security filters).

production-ready

FAQ

Frequently asked questions

Why named groups?

They become column names in the CSV — far easier to read than $1, $2.

What if a line doesn't match?

It's still in the output, marked unmatched. Useful for finding format outliers.

Big files?

Paste up to ~1MB. Larger files: pre-filter with grep then bring chunks here.

Can I export JSON?

Not directly — but the CSV is easy to convert. Or use Regex Extract Groups for JSON output.

Is anything sent to a server?

No. The tool runs entirely in your browser — your pattern and sample text never leave the page.

Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

47 in queue·8 shipped this month

Request queued. Thanks!