Alpha-Numeric Typing Test
Type mixed letters, digits and reference codes — and see what they actually cost you
Everyone knows codes are slower to type than words. Almost nobody can say why, and the usual explanation is wrong. This page measures the text this drill produces, shows where your hands actually go, and works through the one scoring rule that makes the easiest level the least forgiving.
What you will actually be typing
There is no passage here. Every token is built the moment you reach it, which means a string you get wrong will never come round again for a second attempt, and no amount of repetition will teach your hands a specific answer. Below is genuine output from that generator — not examples written to look plausible — one run from each difficulty, with the measured properties of that level underneath.
j7s kjp v0 w9m 5hx gh he qq s7n 4c yk4 9d w2 0w h79 n1 7y h35
7syk MV01W 15hxd EHEG VS7NE yyk4 DSW2S0 h79dn1 ZXG351 24p5 28z1 3amy1 YQFZV 9KU6X L1AZ4 tb4q14 ibsr50 F18DP
7TYKJPMV W9M15GXDGH FDE-4454 E5CYZL4A SW2S0W8 YZC-3719 G3510D24Q F28Z1WQ3AM FQYQFZVBX9 PXR-0637 SWW-6508 UV89204 WT43179 KPN-6111 GBUCC2B ERJJGQWH BVM-4563 MGP-0971
A token is never mixed-case in the middle. It is either all lowercase or all uppercase, which means you always know whether Shift is coming before you reach the letter. Random mid-word capitalisation would add a reading problem on top of the typing one, and this drill is meant to test the second.
Who this test is for
People whose output contains identifiers rather than sentences. Order and invoice numbers in a fulfilment team, SKUs and bin references in a warehouse, policy and claim numbers in insurance, account references read back on a support call, part numbers in procurement. In all of those the surrounding work may be conversational, but the characters that actually have to be exactly right are codes.
It is also the honest diagnostic for anyone whose general typing speed looks fine and whose real-world throughput does not. If plain-text practice has stopped changing anything at work, the loss is probably not in your prose speed at all — it is in the fields, and this is where you can see it isolated.
| Durations | 30 seconds, 1 minute, 2 minutes or 5 minutes |
|---|---|
| Content | Generated tokens — letters, digits and structured reference codes |
| Mode | Word mode only. There is no passage to lose your place in |
| Scoring formula | Each token scored whole — right or wrong, no partial credit — against the 5-keystroke standard word |
| Backspace | On by default, can be turned off in the settings bar |
| Difficulty levels | Easy, Medium and Hard — measured differences below |
| Token length | 2–3 characters on Easy, 4–6 on Medium, 7–10 on Hard |
| Digit share | 28.6% of characters on Easy, 29.1% on Medium, 42.8% on Hard |
| Excluded characters | Capital I, capital O and lowercase l — see the readability section below |
| Repeat content | None. Tokens are generated fresh on every run |
| Report card | Net and gross WPM, accuracy, consistency, plus a mistyped-key list that word mode makes unusually reliable |
| Cost | Free, no login. Scoring runs in your browser and nothing you type is uploaded |
Why codes are slower — and why the obvious explanation is wrong
The explanation you will read everywhere is that mixed letter-and-digit text makes your fingers jump around the keyboard more. That is testable, and on our own text it does not hold up. Adjacent keystrokes change keyboard row on 74.5% of pairs in this drill’s medium set and 69.3% in ordinary prose. Those are close, and prose is closer to the drill than to nothing — English is already spread across three rows, so fluent typing already involves constant row changes.
The difference is not how often you change rows. It is which row, and how far it is.
Number the rows outward from the top — number row 0, top row 1, home row 2, bottom row 3 — and you can measure how far from rest the hand sits. Across general prose the average keystroke lands 0.68 rows from home. In this drill’s medium set it is 1.04, and on Hard it is 1.26. Prose lives on the top and home rows, one step apart. Codes drag the hand a full two rows up and back, repeatedly.
| Text | Number row | Rows from home | Row change | Crossing the number row |
|---|---|---|---|---|
| General prose | 0.1% | 0.68 | 69.3% | 0.2% |
| Word-mode pool | 0% | 0.67 | 66.4% | 0% |
| Alpha-numeric, Easy | 28.6% | 1.06 | 74.4% | 40.8% |
| Alpha-numeric, Medium | 29.1% | 1.04 | 74.5% | 41.2% |
| Alpha-numeric, Hard | 46.5% | 1.26 | 54.4% | 29.2% |
The last column is the one that has no equivalent in ordinary typing. In prose, 0.2% of adjacent keystrokes cross into or out of the number row; in the word-mode pool it is exactly 0%, because there are no digits in it at all. Here it is 41.2% — two transitions in five. That is the rhythm problem, and it is not a metaphor: it is a measured property of the text.
The second cost is prediction, and it cannot be measured the same way because it is a property of language rather than of keystrokes. In a word, the letters you have already typed constrain the next one heavily, which is what allows a fluent typist to run ahead of what they have consciously read. In VS7NE — a real token from the sample above — nothing constrains anything. Every character has to be read, held and executed on its own, and the buffer that normally carries you through a word is empty.
Hard behaves differently again, and against expectation. It crosses the number row less than Medium — 29.2% against 41.2% — because structured references like ABC-2048 group their letters and group their digits, so the hand makes one long move instead of five short ones. What replaces the alternation is Shift: 53.5% of Hard characters need it, against 35.3% on Medium. Hard is not Medium with more of the same; it swaps one difficulty for another.
How your score is calculated, and why Easy is a trap
Scoring is the same everywhere on this site: five keystrokes make one standard word, your total keystrokes divided by five and then by the minutes gives gross WPM, and one standard word is deducted for every token that came out wrong. Nothing about this page changes the formula. What changes is the size of the thing being penalised.
A worked example on Medium. You run the two-minute test, complete 59 tokens, and 353 characters go in including the spaces that commit each one:
| Characters typed, spaces included | 353 |
|---|---|
| Standard words — 353 ÷ 5 | 70.6 |
| Gross WPM — 70.6 ÷ 2 minutes | 35.3 → 35 |
| Tokens typed incorrectly | 9 |
| Net standard words — 70.6 − 9 | 61.6 |
| Net WPM — 61.6 ÷ 2 minutes | 30.8 → 31 |
| Accuracy — 50 correct of 59 | 85% |
Now the part that is specific to this page. The deduction is one standard word — five keystrokes — no matter how long the token was. On Medium a token averages 5 characters, so with its space it is worth 6 keystrokes and getting it wrong still leaves you 0.2 standard words ahead. On Easy the average token is 2.5 characters — 3.5 keystrokes with its space, which is less than a standard word. Get it wrong and it contributes -0.3 standard words. That is a negative number.
| Level | Avg token | Keystrokes incl. space | Net standard words if wrong |
|---|---|---|---|
| Easy | 2.5 chars | 3.5 | -0.3 |
| Medium | 5 chars | 6 | 0.2 |
| Hard | 8.05 chars | 9.05 | 0.81 |
This is a real property of our own instrument and we would rather state it than let you discover it as an unexplained bad score. It is not a bug — the same rule applies on every test on this site and on the exams that use this formula — but it only becomes visible when the unit being scored is shorter than five characters, which on this page it is. There is no way to exploit it either: you cannot skip a token, so the practical lesson is simply that Easy rewards care far more than it rewards pace. If you want a level where speed pays, that is Hard.
The alpha-numeric formats you meet in real work
The tokens here are generated, but the shapes they take are borrowed from identifiers that actually circulate. Each one carries its own failure mode, and knowing which one you are handling is most of the accuracy battle.
| Format | Typical shape | Where the errors come from |
|---|---|---|
| Order and invoice numbers | A short prefix then a running number — INV-40318, SO2260914 | The prefix is muscle memory and the number is not, so you speed up into the digits and misread your own place |
| SKUs and part numbers | Segments encoding attributes — size, colour, revision — often with no separator | Two SKUs can differ in one middle character. Nothing about the surrounding text tells you which one you are holding |
| Policy and account numbers | Long fixed-width digit runs, sometimes with a leading letter class | Fixed width means an omission is invisible — the field still looks full until it is validated |
| Vehicle identification numbers | 17 characters, letters and digits, with a check digit in position nine | Long enough that you lose your place mid-string, and the letters and digits are interleaved rather than blocked |
| Tracking and consignment numbers | Carrier letters followed by a long digit run, frequently read off a label or a screen | Copied by eye from a barcode label, so a misread is indistinguishable from a mistype |
| Booking and confirmation references | Five or six uppercase characters, dictated aloud as often as they are read | All-uppercase means Shift on every letter, and heard references arrive as sounds, not shapes |
What these have in common is that none of them can be proofread the way a sentence can. Language carries redundancy: a misspelling usually produces a non-word, and a reader notices. An identifier carries none. Change one character of SO2260914 and the result is a perfectly plausible identifier that simply belongs to something else — or to nothing. Nothing about the string itself tells you which.
Why real identifier systems throw letters away
You will not find a capital I, a capital O or a lowercase l anywhere in this drill. That is a deliberate exclusion, and it copies what the systems being imitated already do, for a reason worth knowing.
U.S. federal regulation specifies the character set for vehicle identification numbers exactly: every character must be a digit or one of the letters ABCDEFGHJKLMNPRSTUVWXYZ, which drops I, O and Q. A VIN is 17 characters long with a check digit in position nine. The uppercase alphabet this drill uses is that same set with Q added back — we keep Q because on a keyboard it is unambiguous, whereas the regulation is also protecting stamped metal and photocopies. Crockford’s Base 32 encoding makes the same call from the other direction, dropping I, L and O because each can be read as 1 or 0.
The second thing those systems do is check themselves. A VIN’s ninth character is not data — it is computed from the other sixteen by assigning each character a value, multiplying by a position weight, and taking the total modulo 11. Because the weights differ from position to position and 11 is prime, swapping two adjacent characters changes the total unless those two characters happen to share an assigned value.
We tested that claim rather than repeating it
Implementing the calculation from the regulation and running every possible transposition of two adjacent characters at every position of a valid VIN — 14,784 cases — the check digit catches 92.05% of them. Every one of the 1,176 that slip through is a pair sharing an assigned value, because the regulation maps several letters onto the same number: A and J and 1 all count as 1; B, K, S and 2 all count as 2. So a transposed AJ is invisible to the check digit, and a transposed A7 never is.
The practical consequence for a typist is the one worth carrying away. Where a code has a check digit, a single mistyped character is usually caught at the point of entry and costs you a moment. Where it does not — most order numbers, most SKUs, most internal references — nothing catches it, the record saves, and the cost lands days later on somebody else. That asymmetry is why assessments for record-handling roles tend to set a stricter accuracy bar than a speed bar, and it is why practising this drill with backspace off is worth more than practising it fast.
What the three difficulty levels actually change
Difficulty here is a property of the generated text, and it is measured rather than asserted. These figures come from 500,000 sampled tokens per level, produced by scripts/token-stats.mjs, which mirrors the engine’s generator and runs on every deploy.
| Level | Length | Digits | Need Shift | Number row | Rows from home |
|---|---|---|---|---|---|
| Easy | 2–3 | 28.6% | 0% | 28.6% | 1.06 |
| Medium | 4–6 | 29.1% | 35.3% | 29.1% | 1.04 |
| Hard | 7–10 | 42.8% | 53.5% | 46.5% | 1.26 |
Easy to Medium is mostly length and case. The digit share barely moves — 28.6% to 29.1% — but tokens double in length and Shift arrives for the first time, on 35.3% of characters. What Medium really adds is the requirement to hold a longer unpredictable string in mind while your hands execute it.
Medium to Hard is a genuine change in the text. Digits rise from 29.1% to 42.8%, Shift from 35.3% to 53.5%, and the hand sits 1.26 rows from home rather than 1.04. This is a real three-step ladder, which is not true of every corpus on this site — our general prose corpus has a weak Medium-to-Hard step and its page says so. Here the step holds.
Where to go next, based on what went wrong
This is a drill, not a simulation — it isolates one motion deliberately, which means it is the right place to build the skill and the wrong place to rehearse a job. Once the key heatmap has told you where the loss is, the treatment is somewhere more specific.
| If this is the problem | Go here | Why |
|---|---|---|
| The digits themselves are the problem | Numbers test | Pure digit runs, so the number row gets isolated instead of alternating with letters |
| Shifted characters break your hands apart | Symbols test | Drills the Shift coordination that the uppercase codes here demand on every letter |
| You want codes inside real records and forms | Data entry typing test | Puts the same character mix back into structured records, where field accuracy is what is scored |
| Figures, currency and account codes in context | Accounting typing test | Dense numeric text with the proofreading problem that comes with it |
| You look at the keyboard, or you are under 30 WPM on plain text | Learn Typing course | Number-row work on top of unreliable finger placement entrenches the placement |
| You want the practice method rather than another test | How to type faster | The technique guidance lives in one place instead of being repeated on every test page |
One reading tip for the heatmap before you go. The mistyped-key list on this drill is unusually trustworthy, because word mode judges each token on its own — a slip cannot shift everything after it and manufacture a page of fake substitutions the way it can in a passage test. If a digit shows up repeatedly there, that is a real reach problem and it will respond to being drilled directly.
Frequently asked questions
Why is my alpha-numeric speed so much lower than my normal typing speed?
Two things are working against you, and both are measurable in the text itself. Your hand sits further from rest: across this drill's medium set the average keystroke lands 1.04 rows from home position, against 0.68 for ordinary prose. And nothing predicts anything — in a word, the first three letters narrow the fourth to a handful of possibilities, which is what lets fluent typists run ahead of what they have consciously read. In a code every character is independent, so you type one at a time. We cannot tell you what a typical gap is, because nothing you type here is uploaded and we have no cross-user data to draw on. Measure your own: take the general typing test, then take this one at medium, and compare.
Would a numeric keypad make this drill faster?
No, and the measurements say why. A keypad pays off when the right hand can settle on it and stay, which needs long unbroken digit runs. Here the digits are scattered among letters rather than blocked: 41.2% of adjacent keystrokes cross between the digits and the letters at Medium, so the hand would be travelling to the keypad and back to home position constantly, and each of those journeys is longer than the number-row reach it replaced. The keypad is the right tool for the numbers drill, where medium text is 89.8% digits and the hand can park.
Why are there no capital I, capital O or lowercase l in the tokens?
Because they are indistinguishable from 1 and 0 in most screen fonts, and a test that makes you guess is measuring your eyesight rather than your typing. The uppercase alphabet used here is the same one U.S. federal regulation specifies for vehicle identification numbers, with Q added back — that rule drops I, O and Q for exactly this reason. Douglas Crockford’s Base 32 encoding drops I, L and O on the same grounds. Real identifier systems throw letters away to stay readable, so this drill does too.
Why does Easy feel easy but leave me with a poor score?
Because the scoring penalty is fixed at one standard word and Easy tokens are short. An Easy token averages 2.5 characters, so with its space it is worth 3.5 keystrokes — less than the five that make up a standard word. Get it wrong and it contributes -0.3 standard words to your net total, which is a subtraction, not a smaller addition. The same slip on Hard still costs one standard word but the token was worth 9.05 keystrokes, so it nets 0.81. Easy is the least forgiving level on this page, not the most.
Should I turn backspace off for this drill?
Once your accuracy on medium is holding, yes — and this is one of the few drills where the argument is about the work rather than about exam rules. A mistyped reference does not announce itself: the field accepts it, the record saves, and the error surfaces later as a failed lookup or a mis-shipped order. Practising with backspace off trains you to get the string right on the first pass instead of relying on noticing. The toggle is in the settings bar above the test.
Why are the Hard tokens formatted like ABC-2048 rather than fully random?
Because real identifiers are structured, and the structure changes what your hands do. Roughly half the Hard set is shaped — three letters, a hyphen and four digits, or two letters and five digits — with the rest random. The measured consequence is not what people expect: Hard actually crosses into and out of the number row less often than Medium (29.2% of adjacent keystrokes against 41.2%), because grouping the letters and grouping the digits lets the hand settle. What rises instead is Shift, from 35.3% of characters to 53.5%. Hard is not more of the same difficulty; it is a different one.
Do employers actually test alpha-numeric typing?
Assessments for data entry, back-office processing, claims and logistics roles commonly include record fields rather than only prose, because that is what the job produces. We are not going to put a named employer and a WPM threshold next to each other on this page — we have no way to verify a specific company’s current cut-off, and inventing one would be worse than saying nothing. What is safe to say is that where alpha-numeric content appears in an assessment, the accuracy standard is usually stricter than the speed standard, for the reason set out in the check-digit section above.
Is there any point getting faster at this if the codes are usually copied and pasted?
Where a code can be pasted or scanned, it should be — that is a better control than any amount of typing skill. This drill matters for the cases where it cannot: a reference read aloud on a call, a number off a printed label or a photograph, a legacy screen with no clipboard, a field being confirmed rather than entered. Those are also the cases where an error is least likely to be caught quickly, which is why the practice is worth doing carefully rather than fast.
How is this different from the numbers test and the symbols test?
Character mix, and it changes the hand movement completely. The numbers drill is 89.8% digits at medium, so the hand parks on the number row and stays there — it crosses rows on only 24.5% of adjacent keystrokes. This drill is 29.1% digits, and because they are scattered among letters rather than blocked, it crosses 41.2%. The symbols drill trades digits for Shift, holding it on 71.4% of characters at medium. Alternation is this page’s subject; sustained position is the numbers page’s.
Can I practise one specific format, like a 17-character VIN?
Not directly — the generator produces its own shapes rather than letting you specify one, and it is deliberately random so there is nothing to memorise between runs. If you need a particular format, the useful approach is to drill the property it stresses rather than the format itself: long unbroken digit runs on the numbers test, uppercase reference codes on Hard here, and codes embedded in surrounding record text on the data entry test. Practising the exact string is the one thing that will not transfer, because at work the string is different every time.
Sources and method
Every figure describing this drill’s text — token length, digit share, Shift share, keystrokes by keyboard row, rows from home, row-change and number-row-crossing rates — is computed by scripts/token-stats.mjs, which mirrors the generator in our typing engine and samples 500,000 tokens per difficulty with a fixed seed. It runs on every deploy, so the numbers cannot drift away from the code. The seed is fixed deliberately: an unseeded sample would move every figure slightly on each build, and a page citing its own measurements should not wobble.
The prose comparison is measured the same way from the general passage corpus behind our main typing test, and the word-mode comparison from the English word pool the same engine uses. Both are our own text, so the comparison is like for like rather than against a published average.
The VIN character set, the 17-character length, the check digit in position nine and the check-digit arithmetic all come from the regulation itself, cited below, not from a secondary summary. The 92.05% transposition figure is our own result from implementing that arithmetic and enumerating every adjacent transposition; the method is described in full in the section above so you can reproduce it. We have not sourced any employer or assessment typing threshold on this page, because we could not verify one.
- 49 CFR Part 565 — Vehicle Identification Number (VIN) Requirements (§565.13 length and check digit, §565.15 permitted characters and check-digit calculation)U.S. Government Publishing Office · Code of Federal Regulations · link checked 3 Sept 2026
- Base 32 — an encoding whose symbol set drops I, L, O and UDouglas Crockford · link checked 3 Sept 2026