Getting Started with the LikelyTypo Typo Generator

You need realistic typos. Maybe you are building training data for a spell checker, populating a demo with human-looking text, or testing whether your application handles messy input gracefully. Whatever the reason, you need typos that look like genuine human mistakes, not random character noise.

LikelyTypo is a free, web-based typo generator that produces realistic typing errors using keyboard physics. It models adjacent keys, device form factors, hand positioning, and many distinct error types that mirror how people actually mistype. There is nothing to install. You open the page, type or paste your text, adjust a few settings, and get believable typos in seconds. This guide walks you through every part of the interactive generator so you can get exactly the output you need.

Open the Generator

Head to the LikelyTypo generator in your browser. The page loads instantly and works on any modern browser, desktop or mobile. You will see two main panels side by side: a text input area on the left and an output panel on the right. Below the input panels sit the controls for typing profiles, device models, keyboard layouts, and hand usage. Everything runs right in your browser with no signup, no account, and no usage limits.

The generator is organized in a logical top-to-bottom flow. You enter your text at the top, configure the settings below it, and then hit the Generate button. The output appears immediately on the right side. As you experiment with different configurations, the output updates each time you click Generate, letting you compare results across settings in real time.

Enter Your Text

Click the text area labeled "Your Text" and type or paste whatever sentence, paragraph, or passage you want to introduce typos into. The generator accepts up to 5,000 characters, which is more than enough for most use cases. A character counter below the text area shows how much space you have remaining.

For your first try, use something familiar. A sentence like "The quick brown fox jumps over the lazy dog" works well because it contains a wide variety of letters, making it easy to spot different error types in the output. Longer text produces more opportunities for errors, so if you want to see a range of typo patterns, paste a full paragraph.

Once your text is in place, click the large Generate button directly below the input area. The output panel on the right will populate with your text, now modified with realistic typos. Errors are highlighted so you can immediately see what changed. Below the output you will find a stats line showing the seed that was used and how many errors were introduced. You can click "Show error details" to expand a breakdown of every individual error, including its type, position, and what was changed.

Choose a Typing Profile

Directly below the input and output panels you will find a row of buttons labeled Subtle, Typing Fast, Angry Typing, and Very Drunk. These are typing profiles, and they control how aggressively the generator introduces errors into your text. Each profile adjusts the base error rate and the distribution of all error types to simulate a distinct style of human typing. Selecting a different profile and clicking Generate again will produce noticeably different output from the same input text.

Subtle, Typing Fast, and Angry Typing

The most commonly used profiles cover the realistic spectrum of everyday typing behavior:

• Subtle uses a 1.5% base error rate and produces minimal, hard-to-spot errors. Think of a careful typist who occasionally clips a neighboring key or transposes two characters. The mistakes blend naturally into the text and can be difficult to find without careful reading. This profile is ideal when you need test data that closely resembles proofread text with a few slips.
• Typing Fast raises the base error rate to 5%. Errors are more frequent and include skipped characters, doubled keystrokes, and transpositions. The mistakes cluster in longer words where fingers have to travel farther across the keyboard. This is a solid general-purpose starting point.
• Angry Typing pushes the base error rate to 10%. You will see noticeably more substitutions from forceful key presses that land slightly off-target, more insertions from fingers bouncing on keys, and more missed characters from rushing. Use this when you need heavily corrupted text.

The fourth profile, Very Drunk, takes the error rate to 20%. It produces heavily garbled text with frequent substitutions, transpositions, and omissions across nearly every word. This is useful for edge-case scenarios where you need to see how severely degraded input looks or whether downstream systems can handle extreme corruption.

Comparing Profiles

The best way to understand how profiles differ is to run the same input through each one and compare the results. Type a sentence, select Subtle, and click Generate. Note the output. Then switch to Typing Fast and click Generate again. Repeat with Angry Typing and Very Drunk. You will see a clear progression from barely noticeable errors to heavily mangled text. The type of errors shifts too: Subtle tends toward single transpositions and quiet adjacent-key substitutions, while the more aggressive profiles introduce multi-character insertions, omissions, and doubled characters.

To make the comparison even more precise, you can use a fixed seed. Enter a number in the Seed field under Advanced Settings before generating. Using the same seed across all profiles means the underlying random number sequence is identical. The differences in output come entirely from how each profile weights the different error types. This technique isolates the effect of the profile setting from the randomness of the generator.

Pick a Device Model

Below the typing profiles you will find a row of additional controls inside a bordered panel. The first dropdown is labeled "Device" and offers options including Keyboard, Phone Tap, Phone Swipe, and Tablet. Each device model changes the physics of how errors are generated because different input devices produce fundamentally different kinds of mistakes.

• Keyboard simulates a standard physical desktop keyboard. Errors follow key adjacency on the physical layout, and transpositions are common because fingers on a physical keyboard often arrive in slightly wrong order during fast typing.
• Phone Tap models tapping on a phone touchscreen. The touch target is larger and less precise than a physical key, so adjacent-key substitutions have a wider radius. Errors tend to cluster in the center of the keyboard where keys are packed more tightly together.
• Phone Swipe simulates swipe-to-type gesture input. Swipe typing produces unique error patterns including wrong characters from similar swipe paths, missing characters from imprecise gesture endpoints, and character-order errors from the way gesture recognition interprets ambiguous trajectories.
• Tablet models a tablet touchscreen. The larger screen surface means slightly better precision than a phone, but thumb reach from the edges introduces position-dependent errors that differ from both phone and keyboard patterns.

Next to the device dropdown you will also find a Layout selector with keyboard layouts including QWERTY, AZERTY, and QWERTZ. The layout determines which keys the generator considers to be adjacent. On a QWERTY keyboard, the neighbors of "e" are "w", "r", "d", and "s". On an AZERTY layout, the neighbors are different because the key positions are rearranged. Choosing the correct layout for your target audience ensures that the generated typos match the keyboard your users actually type on.

The third control in this row is Hand Usage, which lets you select Both, Right Only, or Left Only. This setting simulates single-handed typing, which changes error distribution because one hand has to reach across the entire keyboard instead of covering only its usual half. Right Only and Left Only are particularly relevant for phone input, where many people type with one thumb.

Try generating the same text with Keyboard selected, then switch to Phone Tap and generate again. The output will contain different error types from the same input. Keyboard output tends toward transpositions and precise adjacent-key hits, while Phone Tap produces wider-radius substitutions that reflect the imprecision of tapping a glass screen.

Get Reproducible Results with Seeds

Every time you click Generate without specifying a seed, the generator picks a random one internally. This means you will get different typos each time, even with the same text and settings. That is useful for exploring the range of possible outputs, but sometimes you need the exact same result again.

After you generate output, look below the output panel for the seed display. It shows the seed number that was used for that particular generation, displayed in a small badge. You can click the clipboard icon next to it to copy the seed value.

To reuse a seed, expand the Advanced Settings panel by clicking the toggle below the device controls. Inside, you will find a Seed input field. Paste or type your seed number there, then click Generate. The output will be identical to what you got before, character for character. Same text, same settings, same seed equals the same result every single time.

Next to the seed field there is a lock button. Clicking it locks the seed so that it persists across multiple generations. This is handy when you want to change other settings like the profile or device while keeping the random sequence fixed, letting you see exactly how each setting affects the output independently of randomness.

Explore Advanced Settings

The Advanced Settings panel contains several additional controls for fine-tuning the generator output. Click the "Advanced Settings" toggle to expand it.

Error Count lets you override the automatic error count that the profile determines. By default it is set to Auto, which means the generator decides how many errors to introduce based on the profile's error rate and the length of your text. You can set it to a fixed number like 1, 2, 3, 5, or 10, or choose Custom to enter any value up to 50. Setting a specific error count is useful when you need precise control over exactly how many mistakes appear in the output.

Error Rate is a slider that controls the percentage of characters that may be affected by typos. Each profile sets this to a default value, from 1.5% for Subtle up to 20% for Very Drunk. Dragging the slider lets you dial in any rate between 0% and 30%, overriding the profile default. The current value is displayed next to the slider label so you can see exactly where you are.

Continuation Probability is a slider that controls the chance of a second error occurring immediately after the first one. In real typing, errors tend to cascade: one mistake throws off finger positioning and leads to another. This slider lets you adjust how strongly that cascading effect applies. Higher values produce clusters of errors in the same word, while lower values spread errors more evenly across the text.

Preserve Digits is a checkbox that, when enabled, tells the generator to leave numeric characters untouched. This is turned on by default. It is useful when your text contains phone numbers, dates, or IDs that should not be corrupted.

At the bottom of the Advanced Settings panel you will find Error Weights, which give you granular control over every individual error type. Each error type has its own slider, and you can increase or decrease the weight of any type to customize the error mix. If you only want adjacent-key substitutions and nothing else, zero out all the other weights. If you want to emphasize transpositions, boost that slider. The Normalize button scales all weights to sum to 1.0, Zero All sets everything to zero, and Reset to Defaults restores the profile's original weight distribution.

When you have changed any advanced setting from its default, a badge appears next to the Advanced Settings toggle showing how many overrides are active. This helps you keep track of your customizations and reminds you to reset if you want to return to standard profile behavior.

What You Learned

You have now explored every part of the LikelyTypo generator. Here is what each section does:

• Text input accepts up to 5,000 characters. Type, paste, and click Generate to see instant results.
• Typing profiles control error intensity. Subtle produces barely visible mistakes, Typing Fast covers general-purpose scenarios, Angry Typing creates heavy corruption, and Very Drunk pushes errors to the extreme.
• Device models shape the physics of each error. Keyboard, Phone Tap, Phone Swipe, and Tablet each produce distinct error patterns that reflect how people actually mistype on different devices.
• Keyboard layouts determine key adjacency. QWERTY, AZERTY, and QWERTZ ensure the generated typos match the physical layout your audience uses.
• Hand usage simulates one-handed or two-handed typing, shifting error distribution based on finger reach.
• Seeds make output deterministic. Lock a seed and the same input with the same settings will always produce the same result.
• Advanced settings offer fine-grained control over error count, error rate, continuation probability, digit preservation, and individual error-type weights.

The output panel highlights every error and gives you a detailed breakdown of what changed, where, and what type of error was applied. You can copy the result to your clipboard with one click, or share it directly to X/Twitter, LinkedIn, or Reddit using the share buttons that appear after generation.

Next Steps

Now that you know how to use the generator, here are some directions to explore:

• Read the introductory deep-dive to understand the keyboard physics model, the many error types, and why physics-based generation produces better results than random mutation. Physics-Based Typo Generation with LikelyTypo covers the theory behind everything you used in this guide.
• Understand the comparison between random character mutation and physics-based generation. Random Character Mutation Fails for Autocorrect Testing shows side-by-side output and explains why the difference matters.
• Experiment with edge cases. Try very short input like a single word, or paste a full page of text. Switch between devices and profiles with a locked seed to isolate exactly how each setting changes the output. Adjust individual error weights to create a custom error mix that matches your specific needs.
• Use the API if you need to generate typos programmatically. The LikelyTypo API provides the same physics-based generation through HTTP endpoints, with all the same profile, device, layout, and seed options available as request parameters.