Email Address Obfuscator
Generates ready-to-paste HTML and JavaScript that display a normal, clickable mailto link to your visitors while hiding the plain-text address from basic scrapers that scan raw page source. Four methods, each shown with a live preview and a verified round-trip check.
Email obfuscation hides a plain-text email address from the simple, high-volume scrapers that crawl the web looking for name@domain.com patterns to add to spam lists — while still showing a normal, clickable mailto link to a human visitor. It is a real, commonly used technique, and it is also a genuinely limited one: the address eventually has to be visible to a human, so nothing done purely in HTML or client-side JavaScript can hide it from a scraper that is willing to execute JavaScript and read the rendered page the way a real visitor's browser does.
This tool generates four methods, honestly labeled by how much they actually defeat, and verifies every one by decoding its own output back to the original address before showing it to you — not just claiming it works.
Table of Contents
What is Email Obfuscation?
Spam harvesters are bots that crawl public web pages, scan the raw HTML source for anything shaped like an email address, and add every match to a list that gets sold or used directly for spam. Most of these bots are simple and cheap to run at scale: they fetch a page's HTML and run a regular expression over it, without executing any JavaScript or rendering the page visually. Obfuscation targets exactly that gap — if the literal text name@domain.com never appears anywhere in the raw HTML source, a regex-based scraper finds nothing, even though a real visitor's browser still shows and can click a working link.
The gap this leaves is equally important to understand: a scraper that does run JavaScript (a real headless browser, which costs more to operate at scale but absolutely exists) sees the exact same rendered page a human does, address and all. No client-side technique — not this tool's, not anyone else's — closes that gap, because the address must become visible to real visitors for the link to work at all.
The Four Methods Compared
HTML Numeric Character References (Decimal & Hex)
Every character of the address — including the @ and . a regex scraper looks for — is replaced with its Unicode code point written as e (decimal) or e (hex). Browsers decode these transparently while rendering, so the page looks completely normal and works without JavaScript. The address is gone from the raw HTML source, but it reappears in full the moment the browser parses and renders the page, so it's present in the rendered DOM and in anything that reads .textContent — including a JavaScript-capable scraper.
JavaScript with Character Codes
The address is stored as an array of character codes (plain numbers, meaningless without the decode step) and reassembled into a link only when the page's JavaScript runs, via document.write. A scraper that only reads raw HTML source finds literally nothing — not even an entity-encoded hint. A <noscript> fallback (entity-encoded, same protection level as method one) keeps the link working for the small number of visitors browsing with JavaScript disabled.
JavaScript with a ROT13 Cipher
Functionally equivalent to the character-code method — the address isn't in the raw HTML at all — but the address is shifted letter-by-letter (ROT13) rather than listed as one number per character, which produces noticeably shorter generated code for longer addresses. The @, ., and digits pass through the cipher unchanged, which is normal and doesn't weaken it; a ROT13 cipher only has an effect on letters.
How the Tool Works
- Build the mailto target. The email address, plus any subject and body you provided, are assembled into a standard
mailto:address?subject=...&body=...URL, with the subject and body properly percent-encoded. - Encode by method. For the entity methods, every character of both the link's href and its visible text is converted to a numeric character reference. For the JavaScript methods, the same two strings are either split into a character-code array or run through a ROT13 cipher, and wrapped in a small script that reconstructs and writes the link at page-load time.
- Verify by decoding. Each method's own inverse operation (entity decoding, or
String.fromCharCode, or running ROT13 a second time) is applied to the generated output and compared character-for-character against your original input — this is what the verification badge on each result reflects. - Render a live preview. Each generated snippet is rendered inside a small sandboxed preview pane exactly as it would appear embedded in a real page, so you can see — not just trust — that it produces a normal, clickable link.
Output Verification
Every generated snippet is decoded back to plain text using the exact inverse of its own encoding — real numeric-entity decoding for methods one and two, the identical String.fromCharCode reconstruction a browser's JavaScript engine would run for method three, and a second ROT13 pass (which is self-inverse: applying it twice always returns the original) for method four — and compared against your original input. The "Round-trip verified" badge only appears when that comparison matches exactly.
Which Method Should You Pick?
| Method | Defeats | Doesn't Defeat | Needs JavaScript? |
|---|---|---|---|
| HTML Decimal/Hex Entities | Basic regex-on-raw-HTML scrapers | Rendered-DOM readers, JS-capable scrapers, anyone viewing the live page | No |
| JavaScript (Character Codes) | All regex-on-raw-HTML scrapers (address isn't present at all) | JS-capable scrapers, anyone viewing the live page | Yes, for the protected version — the <noscript> fallback is entity-encoded only |
| JavaScript (ROT13) | Same as character-codes, with shorter output | Same as character-codes | Yes, for the protected version — same fallback |
For most sites, the JavaScript character-code or ROT13 method is the better default: it removes the address from raw HTML entirely rather than just re-encoding it, which is what stops the large majority of real-world harvesters (simple regex crawlers, not headless-browser scrapers, make up the bulk of email-harvesting traffic). The entity methods are a reasonable choice specifically when you need the link to work with JavaScript disabled and are willing to accept weaker protection for that guarantee.
Limitations & What This Doesn't Do
- Nothing stops a JavaScript-capable scraper. If a scraper runs a real or headless browser and reads the rendered page, every method here shows it the exact same address a human visitor sees. This is a hard limit of any client-side technique, not a shortcoming specific to this tool.
- Not encryption. ROT13 and character-code arrays are trivially reversible by design — the point is to keep the address out of raw HTML, not to make it cryptographically secret.
- Doesn't stop manual collection. Anyone who can see your page can read and copy the address by hand, exactly as they could with a plain, unobfuscated link.
- Accessibility. Numeric character references and the
<noscript>fallback both render as ordinary text to screen readers, so neither method harms accessibility. (This is also why this tool doesn't implement CSS direction-reversal "visual trick" obfuscation some sites use — those read incorrectly, or not at all, to screen readers, which is a real cost for a very modest scraper-deterrence benefit.) - A dedicated contact form is often the stronger choice. If avoiding spam matters more than displaying a literal address, a contact form that emails you server-side (never printing the address in the page at all) sidesteps this entire category of risk.
Use Cases
Business & Portfolio "Contact" Pages
A visible hello@yourcompany.com link on a contact or team page is one of the most commonly harvested patterns on the web. Obfuscating it cuts down the volume collected by simple crawlers without removing the convenience of a one-click mailto link.
Blog Author Bylines
Personal and company blogs that list an author's email alongside their name are a frequent scraper target; obfuscating that one line protects it without changing how the byline reads.
Staff & Directory Listings
Pages listing multiple staff emails (a "Team" or "Departments" page) are especially valuable to harvesters because of the volume in one place — obfuscating each entry is a quick mitigation while keeping the directory genuinely useful to visitors.
Frequently Asked Questions
What is email obfuscation and why would I use it?
Is this tool free?
Is my email address uploaded anywhere?
Which method should I use?
Does this stop all spam bots?
Will the JavaScript methods work for visitors with JavaScript disabled?
What does "round-trip verified" mean?
Can I include a pre-filled subject and body?
Does obfuscating my email hurt accessibility or SEO?
Why doesn't this tool offer a CSS-based "reversed text" trick?
Should I use this instead of a contact form?
Conclusion
Email obfuscation is a genuinely useful, low-effort layer against the large volume of simple scrapers that crawl the web for raw-HTML address patterns — not a guarantee against spam from every possible source. This tool gives you four honestly labeled methods, a live preview of exactly how each one renders, and a verified round-trip check on every result, so what you copy and paste is something you've actually seen work, not just something you're told works.