Levenshtein Distance Calculator

Definition and formula for Levenshtein distance

In Levenshtein distance, the score between two strings A and B is the minimum number of insertions, deletions, and substitutions required to transform A into B. The calculator follows the classic dynamic-programming approach, which means it compares every prefix of one string against every prefix of the other and keeps the cheapest edit path it has found so far.

Let i be the length of the prefix of A and j the length of the prefix of B. The value d(i, j) is the Levenshtein distance between the first i characters of A and the first j characters of B. The recurrence is:

Here, cost = 0 if the i-th character of A equals the j-th character of B, and cost = 1 otherwise. The first row and first column of the matrix are initialized to represent distances involving an empty string:

• d(0, j) = j (all insertions)
• d(i, 0) = i (all deletions)

The final answer is d(|A|, |B|), where |·| denotes string length. Because the score is based on the cheapest edit path, the calculator always favors the shortest exact sequence of text edits rather than a rough visual guess.

Worked example: editing "kitten" into "sitting"

A classic Levenshtein example compares the words kitten and sitting. The calculator treats the difference as a sequence of character edits, and one optimal route looks like this:

1. Substitute k with s: kitten → sitten
2. Substitute e with i: sitten → sittin
3. Insert g at the end: sittin → sitting

That path uses three single-character edits, so the Levenshtein distance between kitten and sitting is 3. The important point is not the example itself but the method: the calculator checks every plausible combination of insertions, deletions, and substitutions, then reports the smallest count it can prove.

How to interpret a Levenshtein distance result

The Levenshtein calculator returns a non-negative integer, and the simplest way to read that number is as a measure of editing effort:

• 0: the two strings are exactly the same.
• 1–2: the strings are very close, usually differing by a typo, a missing character, or a single replacement.
• 3–5: the strings are still related, but the differences are large enough that you should inspect whether they are alternate spellings, truncated text, or different entries.
• Higher values: the strings diverge more strongly and are less likely to describe the same item.

Keep in mind that a raw Levenshtein distance is length-sensitive. Three edits may be trivial in a long product name and significant in a short code or username. If you need a closer comparison between strings of different lengths, you can normalize the score outside this calculator, but the value shown here is the plain edit distance only.

Comparison with other string similarity metrics for Levenshtein distance

Levenshtein distance is one of several ways to compare strings, and the best metric depends on the type of mismatch you expect. The table below places this calculator's score next to a few familiar alternatives so you can see when the Levenshtein approach is the most natural fit.

If your task needs one of these variants, this page still gives you a solid baseline score under the classic Levenshtein definition. That makes it easy to compare exact edit counts before deciding whether a different similarity metric is a better match for your workflow.

Assumptions and limitations of this Levenshtein Distance Calculator

To keep the Levenshtein calculator predictable, the implementation uses a few straightforward rules that are worth remembering before you rely on the score:

• Equal edit costs: Insertions, deletions, and substitutions all cost 1. There is no weighting by character type, keyboard layout, or position in the string.
• Exact character matching: Characters are compared exactly as entered. By default there is no case folding, accent/diacritic normalization, or Unicode canonicalization unless explicitly performed on your side before input.
• No transposition operation: Swapping two adjacent characters (e.g., ab → ba) counts as two edits (delete + insert or two substitutions), not one. This differs from Damerau–Levenshtein distance.
• Performance on very long strings: The dynamic programming algorithm runs in time and memory roughly proportional to the product of the two string lengths. Extremely long inputs (for example, tens of thousands of characters each) may be slow or impractical in a browser environment.
• Raw distance only: The calculator reports the distance, not a normalized similarity score or probability. If your workflow needs a 0–1 similarity value, you will need to transform the result accordingly.

These constraints are typical for a reference implementation of Levenshtein distance and are well suited to everyday text comparison tasks. They are especially useful when you want a transparent score that tells you how far apart two strings are without adding extra assumptions.

Where Levenshtein distance is useful in text matching

Because the Levenshtein distance is simple, consistent, and easy to explain, it shows up in many places where text needs to be compared without requiring an exact match:

• Spell checking and autocorrect: Suggest words from a dictionary that are closest to a misspelling, such as mapping recieve to receive.
• Fuzzy search: Match user queries that are slightly mistyped against product titles or article names.
• Record linkage and deduplication: Identify near-duplicate customer names across databases (for example, Jon Smith vs John Smyth).
• Data cleaning: Standardize free-text entries that contain minor variations, abbreviations, or missing characters.
• Bioinformatics and sequences: Compare DNA, RNA, or protein sequences, treating each base or amino acid as a character (often with domain-specific extensions).

In each of these settings, a lower Levenshtein distance suggests a closer match. Teams often set their own cutoff for what counts as “close enough,” and the calculator makes it easy to see whether two strings fall below or above that threshold.