How is a TOTP code calculated from a secret?

The Base32 secret is decoded to raw bytes (RFC 4648). A time-step T = floor(unixTime / 30) is packed into 8 bytes and HMAC-SHA-1'd with the secret (RFC 4226). Dynamic truncation takes 4 bytes at an offset given by the HMAC's last nibble, masks the top bit, and the resulting 31-bit number modulo 10^6 is your 6-digit code.

What is the difference between TOTP and HOTP?

HOTP (RFC 4226) is counter-based: the counter increments by one each time a code is used. TOTP (RFC 6238) is the same algorithm but the counter is derived from the clock — floor(current Unix time / 30) — so codes rotate automatically every 30 seconds without either side tracking a counter.

How long is a 2FA code valid? What is the 30-second window?

By default a code is valid for one 30-second period. The window starts at each multiple of 30 seconds of Unix time, so all codes in the same block are identical and change at :00 and :30 of each minute. Many servers also accept the previous and next code to tolerate small clock drift.

My authenticator code doesn't match — is it a clock or time-drift problem?

Usually, yes. TOTP depends on both devices agreeing on Unix time. If a code is rejected, check that the server clock is synced (NTP) and that the period is 30 seconds, not 60. Use this tool's custom-timestamp mode to compute the code for the exact second your server used and compare.

Is it safe to generate 2FA codes on a website?

This tool computes everything in your browser with the Web Crypto API — open your network tab and you will see no request carries the secret. Even so, for a live account the secret should stay only inside your authenticator app. Use this for test secrets, learning, and debugging your own implementation.

Which algorithm and digit length should I use?

Almost every service uses SHA-1, 6 digits, 30-second period — that is what Google Authenticator assumes when an otpauth URI omits these. SHA-256 and SHA-512 are supported by RFC 6238 and some enterprise systems; 8-digit codes are occasionally used. Match whatever your server sets, or the codes will differ.

What secret does the QR code contain?

The QR encodes an otpauth://totp/ URI (Google's Key Uri Format) holding the Base32 secret plus issuer, account label, algorithm, digit count and period. Any authenticator app scans it to add the account. The secret is generated locally from crypto.getRandomValues at 160 bits, the length RFC 4226 recommends.

Can I import this into Google Authenticator or Authy?

Yes. In the 'New secret + QR' tab, scan the QR with Google Authenticator, Authy, 1Password, or Microsoft Authenticator — all read the standard otpauth URI. To verify it worked, copy the generated secret into the 'Code from secret' tab and confirm the codes and countdown match your app.

Utility · Security

TOTP / 2FA Authenticator Code Generator

Turn a Base32 secret into the live 6- or 8-digit authenticator code your 2FA app would show right now — with a countdown to the next code — or generate a fresh secret plus a scannable QR to set up two-factor authentication. RFC 6238, runs entirely in your browser.

By Induwara Ashinsana— Executive Director, Ryzera TechnologiesUpdated Jul 15, 2026

TOTP / 2FA code generator

For testing and learning only. Use a throwaway or test secret — never paste a live production account's 2FA secret into any website, including this one. Everything here runs in your browser; your secret is never sent anywhere.

Base32 secret

Letters A–Z and digits 2–7. Spaces, hyphens and lower-case are accepted; padding is ignored.

Algorithm

Digits

Period (seconds)

Time source

Computing…

Follows RFC 6238 (TOTP), RFC 4226 (HOTP) and RFC 4648 (Base32). Algorithm last cross-checked against the RFC 6238 test vectors on 2026-07-15. Full sources are listed below the tool.

How it works

A time-based one-time password (TOTP) is HOTP evaluated at a clock-derived counter. This tool follows the two standards exactly — RFC 6238 for the time step and RFC 4226 for the HMAC and truncation — computing everything locally with the browser's Web Crypto API. The secret never leaves your device.

Decode the secret. The Base32 string (RFC 4648 §6, alphabet A–Z and 2–7) is decoded to the raw key bytes K. Lower-case, spaces, hyphens and = padding are tolerated.
Compute the time step. T = floor((now − T0) / X) with T0 = 0 and X = period (default 30 s). T is encoded as an 8-byte big-endian integer.
HMAC. H = HMAC-Hash(K, T), where Hash is SHA-1, SHA-256 or SHA-512. This is a 20-, 32- or 64-byte value.
Dynamic truncation (RFC 4226 §5.3). Let offset = H[last byte] & 0x0F. Take the 4 bytes at that offset and mask the top bit: binCode = (H[offset] & 0x7F)≪24 | H[offset+1]≪16 | H[offset+2]≪8 | H[offset+3].
Reduce to digits. OTP = binCode mod 10^digits, left-padded with zeros. For 6 digits that is mod 1,000,000.

The derivation panel inside the tool shows every one of these intermediate values for the current code, so you can line them up against your own implementation byte for byte. On load, the tool also recomputes the official RFC 6238 Appendix B test vectors for SHA-1, SHA-256 and SHA-512 and confirms each matches — that is the “RFC 6238 verified” badge. To create a new account, the “New secret + QR” tab draws a 160-bit key from crypto.getRandomValues and assembles a Google Key-Uri-Format otpauth://totp/… URI rendered as a QR code.

Worked examples

RFC 6238 vector — T0 window

Secret GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ · SHA-1 · period 30 · Unix 59

Time step: T = floor(59 / 30) = 1 → 0x0000000000000001
HMAC-SHA-1(K, T) → 20-byte digest
Dynamic truncation → 31-bit binCode = 1094287082
8 digits: 1094287082 mod 10^8 = 94287082
6 digits: 1094287082 mod 10^6 = 287082

RFC 6238 vector — later window

Same secret · SHA-1 · period 30 · Unix 1,111,111,109

Time step: T = floor(1111111109 / 30) = 37037036 → 0x00000000023523EC
HMAC-SHA-1(K, T) → dynamic truncation
8 digits → 07081804
6 digits → 081804
Both match RFC 6238 Appendix B exactly.

Demo secret cross-check (edge: Unix 0)

Secret JBSWY3DPEHPK3PXP · SHA-1 · 6 digits · period 30 · Unix 0

Time step: T = floor(0 / 30) = 0 → 0x0000000000000000
HMAC-SHA-1(K, 0) → dynamic truncation → mod 10^6
Result: 282760
This is the value otplib and pyotp return for TOTP('JBSWY3DPEHPK3PXP').at(0),
a second reference point independent of the RFC vectors.

Frequently asked questions

Sources & references

The algorithm on this page was last cross-checked against the RFC 6238 Appendix B test vectors (SHA-1, SHA-256 and SHA-512) and the otplib/pyotp demo-secret value on 2026-07-15. The check re-runs in your browser every time the tool loads.

Related tools

LiveUtility

QR Code Generator

Generate QR codes for URLs, text, Wi-Fi, vCards, email, phone, or SMS. Customise colours, set error-correction level, add a centre logo. Encoded entirely in your browser, no signup, downloads as PNG or SVG.

Open tool

LiveUtility

UUID Generator

Generate UUID v4 (random) or v7 (time-ordered) in your browser. Bulk up to 1,000 at a time, copy or download as .txt/.csv, inspect any UUID for version, variant, and embedded timestamp. RFC 9562 conformant.

Open tool

LiveUtility

Barcode Generator

Generate scannable 1-D barcodes in Code 128, EAN-13, UPC-A, ITF, Code 39, and Codabar formats. GS1 check digits calculated and verified for you. Download as PNG or SVG, encoded entirely in your browser.

Open tool

Rate this tool

Be the first to rate

Comments & feedback

Spotted a bug or want an improvement? Tell us — our team reviews every comment, and good ideas get built. Comments are public and anonymous.

Found a bug, edge case, or want to suggest an improvement?

Email me at [email protected] — most fixes ship within 24 hours.