In1.

Regex tester

Write a regular expression and see it match your text in real time. Matches are highlighted, capture groups are listed, and you can toggle flags — all instantly and privately in your browser.

Loading tool…
All Web tools

How to use Regex Tester

  1. 1

    Write your pattern

    Type a regular expression in the pattern field.

  2. 2

    Choose flags

    Toggle global, ignore-case, multiline, dotall and unicode flags as needed.

  3. 3

    Add test text

    Paste the text you want to match against in the test box.

  4. 4

    Read the results

    Matches are highlighted live, with a count and any capture groups listed.

See your pattern match in real time

Regular expressions are powerful but notoriously easy to get wrong, and the only reliable way to know whether one works is to run it against real text and look at what it catches. This tester gives you that feedback instantly. You type a pattern in one box and your sample text in another, and every match is highlighted directly in the text as you go, with a running count of how many were found. There is no run button to press and no waiting — the highlighting updates with each keystroke, so you can refine a pattern and watch the effect immediately. This tight loop is what makes building a regex manageable: instead of writing the whole thing and hoping, you grow it piece by piece, confirming at each step that it still matches what it should and nothing it shouldn't. Seeing the matches in context, rather than as an abstract list, also makes it obvious when a pattern is catching too much or missing an edge case.

Toggle flags to change how matching works

Flags change the behavior of a regular expression in important ways, and the tester lets you switch them on and off with a click so you can see their effect immediately. The global flag finds every match rather than stopping at the first. The case-insensitive flag makes letters match regardless of capitalization. The multiline flag changes how the start-of-line and end-of-line anchors behave across multiple lines. The dotall flag lets the dot match newline characters, which matters when your text spans several lines. The unicode flag enables proper handling of characters beyond the basic range. Understanding which flag does what is half of mastering regular expressions, and being able to flip each one and instantly watch the matches change is the fastest way to build that intuition. It also saves real debugging time, because a pattern that 'isn't working' is very often just missing a flag, and the tester makes that easy to spot and fix.

Inspect capture groups, not just matches

Matching is only part of what regular expressions do; capture groups let you pull specific pieces out of each match, and getting them right is essential when you are extracting or rearranging data. The tester shows the capture groups for each match, so you can confirm that your parentheses are grabbing exactly the parts you intend. This is invaluable when you are using a regex to extract fields from log lines, parse a structured string, or reformat text with group references in a replacement. Instead of guessing whether group one is the area code and group two is the number, you can see the captured values laid out for every match and verify your pattern before you rely on it elsewhere. Seeing the groups also helps you debug a pattern that matches the right overall text but captures the wrong pieces inside it — a subtle bug that is almost impossible to catch by looking at the matches alone, but obvious once the groups are spelled out.

Private by design — tested in your browser

The text you test a pattern against is often real, sometimes sensitive: log files, user data, source code, exported records or anything else you happen to be parsing. There is no reason to send it to a server just to run a regex, and good reason not to. In1 evaluates your pattern entirely in your browser using the JavaScript regular expression engine, so both the pattern and the test text stay on your own device. Nothing is uploaded, nothing is stored and there is no account. Matching is instant because there is no network round trip, and it works exactly the same offline as online. If your pattern is invalid, the tester tells you what is wrong instead of failing silently, so you can fix it and carry on. You can paste a large block of text and test against all of it without worrying about where it goes. It is the convenience of an online regex tester with the privacy of running the pattern locally — which is what real, sensitive test data calls for.

Who uses a regex tester?

Regular expressions show up far beyond programming, and so do the people who need to test them. Developers build and debug patterns for validation, search, parsing and text transformation in every language, and a tester is the quickest way to confirm a pattern before dropping it into code. Data analysts and engineers craft expressions to clean, extract and reshape messy data. QA testers write patterns to validate input formats and check output. SEO and marketing specialists build regex for analytics filters, redirect rules and search-and-replace operations. System administrators use them in log analysis and configuration. Writers and editors occasionally reach for regex to perform sophisticated find-and-replace. Students learning the syntax use a live tester to understand how each construct behaves. For all of them, being able to type a pattern, see it match real text instantly, flip flags, and inspect capture groups — privately, with no setup — turns the often-frustrating process of getting a regex right into something fast and almost interactive.

Get more from In1

Higher limits, batch processing and an API are on the way. Want early access?

Frequently asked questions

More Web tools