Menu

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.

Obfuscation Studio Free
Ready
All processing runs in your browser. Your email address is never uploaded. No obfuscation method fully stops a scraper that executes JavaScript and reads the rendered page — see the honest comparison in the guide below before picking one.
Complete Guide to Email Obfuscation

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.

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

  1. 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.
  2. 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.
  3. 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.
  4. 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.

Why this matters: an obfuscator that silently mangles an address (a dropped character, a broken escape) is worse than no obfuscation at all — the link quietly stops working and you don't find out until a real customer can't reach you. Verifying before display catches that class of mistake instead of asking you to trust it.

Which Method Should You Pick?

MethodDefeatsDoesn't DefeatNeeds JavaScript?
HTML Decimal/Hex EntitiesBasic regex-on-raw-HTML scrapersRendered-DOM readers, JS-capable scrapers, anyone viewing the live pageNo
JavaScript (Character Codes)All regex-on-raw-HTML scrapers (address isn't present at all)JS-capable scrapers, anyone viewing the live pageYes, for the protected version — the <noscript> fallback is entity-encoded only
JavaScript (ROT13)Same as character-codes, with shorter outputSame as character-codesYes, 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?
Email obfuscation hides a plain-text address from simple, high-volume spam-harvesting bots that scan raw HTML source for name@domain.com patterns, while still showing a normal clickable mailto link to real visitors. It reduces the spam a publicly listed address collects, though it can't eliminate it entirely — see the limitations section for the honest boundary.
Is this tool free?
Yes. The tool is completely free with no registration, no limits, and no hidden fees. All processing happens in your browser.
Is my email address uploaded anywhere?
No. Every method runs entirely as JavaScript inside your browser. The address you type is never sent to a server.
Which method should I use?
For most sites, one of the two JavaScript methods (character codes or ROT13) is the stronger default, since it removes the address from the raw HTML entirely rather than just re-encoding it in place. Use an HTML entity method instead only if the link must keep working with JavaScript disabled and you're fine with weaker protection in exchange for that.
Does this stop all spam bots?
No, and no obfuscation tool honestly can. It stops the large share of scrapers that only read raw HTML source with a regex and don't execute JavaScript. A scraper running a real or headless browser sees the exact same rendered page a human visitor does, address included — that's a hard limit of any client-side technique, not a gap specific to this tool.
Will the JavaScript methods work for visitors with JavaScript disabled?
Yes, through the included <noscript> fallback, which uses the same entity-encoded link as method one. It's weaker protection than the JavaScript version, which is an inherent trade-off of supporting non-JavaScript visitors at all, not a flaw in the fallback itself.
What does "round-trip verified" mean?
After generating each method's code, the tool decodes that exact output back to plain text — the same way a browser or its own JavaScript would — and checks it matches your original input character-for-character. This catches encoding mistakes before you ever paste the code into your site, rather than asking you to trust that it works.
Can I include a pre-filled subject and body?
Yes. Anything entered in the Subject or Body fields is properly URL-encoded and added to the mailto link as standard subject= and body= parameters, supported the same way in every generated method.
Does obfuscating my email hurt accessibility or SEO?
Numeric HTML entities and the <noscript> fallback both render as completely normal text to screen readers, so accessibility isn't affected by either. Search engines generally don't index raw email addresses as meaningful content regardless of obfuscation, so there's no real SEO trade-off either way.
Why doesn't this tool offer a CSS-based "reversed text" trick?
That technique (writing the address backwards and using CSS to visually reverse it) reads incorrectly, or not at all, to screen readers — a real accessibility cost for a scraper-deterrence benefit no stronger than the methods already offered here. It's deliberately left out rather than included as a flawed option.
Should I use this instead of a contact form?
If minimizing spam matters more to you than displaying a literal, clickable address, a server-side contact form that never prints the address in the page's HTML at all is the stronger choice. This tool is for situations where you specifically want a visible mailto link, just a harder-to-harvest one.

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.