Skip to content
TextLab

Free email extraction from any text

Extract emails from text, even when they are hidden

Paste a document and this page lists every email address inside it — including the ones written to dodge robots, such as priya [at] example dot com, dan(at)example.com or kim@example.com — rewritten as ordinary addresses. It is free, takes no signup, and every result is measured against the shape RFC 5322 allows, so a doubled dot, a 70-character mailbox name or a domain with no ending is flagged with the rule it broke rather than quietly joining your list. Each row shows the words the address was written in, so you can see exactly what the author typed.

  • 100% free
  • No signup
  • Reads [at] and (dot) forms
  • RFC 5322 shape check
  • Shows the sentence it came from
0addresses in this text0 written the long way · 0 need a second look

Reading at and dot as words is a guess, and a sentence like “we meet at example.com weekly” can be read as an address. Each row shows the words it came from, so you can throw the guess out.

How to get the addresses out of a document

Three steps, and the first reading appears before you let go of the paste.

  1. Paste the document you are reading

    An email thread, a conference programme, a page of a PDF, a forum post, a supplier brief — whatever holds the addresses you need. Press ⌘V (Ctrl+V on Windows) anywhere on this page and it lands in the box. Try a scrambled example fills the box with a paragraph in which six addresses are written four different ways, one of them with a typo in the domain, if you want to see the reading before you trust it with your own text.

  2. Read the rows, not just the addresses

    Every distinct address appears once, with the exact words it was written in underneath and the address it resolves to above. Clean means the shape is sound; Unscrambled means the document did not write it as an address and this page rewrote it; Possible slip means the domain is one keystroke from a common one; Needs a look means a rule was broken, and the row names which rule.

  3. Take the ones you trust

    The three buttons copy the addresses that passed, every address including the flagged ones, or a mailto: link with the valid addresses already in the To field — click that into a browser and your mail client opens with the message half written. Use the filter buttons first if you only want to look at what needs fixing.

Technical specifications

Disguises it can read[at] (at) {at} <at> and the same four around dot, spaced @ as in kim @ example.net, -at- and _at_, -dot- and _dot_, d0t, the fullwidth @ and ﹫, the HTML entities &#64; and &#46;, and the fully worded name at domain dot com
Shape rules applied64 characters before the @, 255 after it, 254 in total, 63 per domain label; no leading, trailing or doubled dot in the mailbox name; only the RFC 5322 unquoted character set outside quotes; no hyphen at the edge of a label; no all-digit and no single-letter ending
Flagged as unusual rather than wrongQuoted mailbox names, addresses pointing at a bracketed IP address, punycode xn-- endings, and non-ASCII characters that need an SMTPUTF8 server
Typo hints26 checks: 18 look-alike domains including gmial.com, gamil.com, hotnail.com and outlok.com, plus 8 endings such as .con, .cmo and .ogr
How results are listedEach distinct address once, with the number of times it appeared, the words it was written in, and 52 characters of the sentence on either side
Measured speedA 100,000-character document is read, unscrambled and checked in about 45 ms; a full megabyte takes roughly 0.19 s on an Apple M-series laptop
Where the reading happensIn this browser tab; the document is never uploaded and no address is sent anywhere, including to us
PriceFree, no signup, no cap on document length or on how many you read

Frequently asked questions

Is a plus sign allowed in an email address?

Yes, and it is a perfectly ordinary character before the @. RFC 5322 permits the punctuation set ! # $ % & ' * + - / = ? ^ _ ` { | } ~ in an unquoted mailbox name alongside letters and digits, so anna+newsletter@example.org is as valid as anna@example.org — it is simply a label the recipient added for their own filing. Some signup forms reject the plus sign anyway, which is a bug in the form rather than a fault in the address, and it is the single most common false rejection on the web.

Does this check whether the address actually exists?

No, and nothing running in a browser can. What is checked is shape: the length limits, where dots may and may not sit, which characters are permitted where, and whether the domain has a plausible ending. Whether anyone reads mail at that address is known only to the server that accepts it, and even that server often will not say — a domain with a catch-all rule accepts every address at SMTP time and bounces later, and probing mailboxes one by one gets you rate-limited or blocklisted for behaving like a dictionary attack. The reliable sequence is a shape check here, then a real message, then watching the bounces.

Why do people write addresses as name [at] domain dot com?

To hide them from the programs that read web pages looking for the @ sign. The habit dates from the early 2000s spam surge: a 2003 study by the Center for Democracy & Technology planted fresh addresses in public places and reported that the ones published in plain text on web pages collected nearly all the spam it recorded, while the same addresses written with the @ spelled out collected none. Modern harvesters read the common disguises perfectly well, so the practice now mostly inconveniences the humans it was never aimed at — which is the reason this page exists.

It found an address in a sentence that was not one — why?

Because reading the bare words at and dot as punctuation is a guess, and a sentence like “we meet at example.com on Tuesdays” has exactly the shape of a disguised address. The guess only fires when a domain-looking tail follows, so “meet at noon” is left alone, but “meet at example.com” is not. Every row shows the words the address came from precisely so you can throw a bad guess away, and the tick box above turns the worded forms off entirely — bracketed forms like [at] and (dot) keep working when it is off, since those are never accidental.

Is an address like “john smith”@example.com real?

Yes — a quoted mailbox name is part of the standard, and inside those quotes a space is legal, along with characters that would otherwise be forbidden. It is flagged here as unusual rather than wrong, because the number of web forms, CRMs and mailing platforms that will accept one is small, and a quoted address that works in one system routinely fails in the next. If you meet one in a document, the safest move is to ask its owner for a plain form rather than to argue with a signup form about the specification.

Can an email address contain accented or non-Latin letters?

It can, but only where both mail servers agree to it. An address such as joão@correio.pt or 用户@例子.测试 needs the SMTPUTF8 extension defined in RFC 6531, and plenty of servers, especially older corporate ones, still refuse anything outside plain ASCII. Domains have a fallback the mailbox does not: a non-Latin domain can be written in its punycode form beginning xn--, which every server understands. Addresses of either kind are marked here as unusual, with the reason spelled out, rather than being called invalid.

How long is an email address allowed to be?

Sixty-four characters before the @, 255 after it, and 254 for the whole thing. The last figure surprises people: it comes from the mail protocol allowing a 256-character forward path, of which two characters are the angle brackets wrapped around the address. A mailbox name of 70 characters is therefore invalid however sensible it looks, and this page reports the exact length it measured rather than a bare rejection.

What the standard allows, and what a check can never promise

Email addresses are far stranger than the forms that reject them believe. RFC 5322 lets an unquoted mailbox name carry letters, digits and eighteen pieces of punctuation — ! # $ % & ' * + - / = ? ^ _ ` { | } ~ — so o'brien+invoices@example.org is entirely ordinary and !def!xyz%abc@example.org is legal too. Put the name in quotes and a space becomes permissible; the grammar even allows comments in round brackets inside an address. The consequence is famous: the best-known attempt to express the standard as a single regular expression runs to several thousand characters, and it still accepts addresses no mail server on earth would deliver to. Chasing that is the wrong goal. What is worth checking is the handful of rules that are unambiguous and that people genuinely break — 64 characters before the @, 254 overall, 63 per piece of the domain, no dot at either edge of the mailbox name and never two together, no hyphen at the edge of a domain label, and an ending that is letters rather than digits. Those are the checks behind the badges above, and when one fails the row says which one, because “invalid” on its own tells you nothing you can act on.

No amount of that proves an address works. Shape is a statement about the writing; delivery is a fact about somebody else's server, and the two part company constantly. sam.hollis@gmial.com is flawless by every rule in the specification and will bounce for the rest of its life, which is why the domain typo list runs alongside the shape check rather than inside it. In the other direction, a domain configured to catch all mail accepts anything before the @ at the moment of delivery and discards it quietly afterwards, so even a live test tells you less than it appears to. Verification services exist and they work by talking to the receiving server, which is something a static page cannot do and would not do without sending your document somewhere. The honest order of operations is to fix the shape here, send one real message, and read the bounces — and if the addresses arrive by the thousand rather than by the paragraph, the bulk email extractor is built for volume, de-duplication and domain filtering instead of close reading.

The disguises are worth understanding rather than merely decoding. Writing name at domain dot com was a rational defence when harvesters did little more than search a page for the @ character, and it measurably worked at the time. It stopped working years ago — anything scraping addresses today reads the bracketed and worded forms as easily as this page does — but the habit survived in conference programmes, academic staff pages, forum signatures and privacy policies, and the people it now inconveniences are readers with a legitimate reason to write. Ten rewriting rules cover what turns up in practice, including the fullwidth @ that Japanese and Chinese input methods produce and the HTML entity &#64; that a copied web page leaves behind. Reading the bare words at and dot is the one rule that can misfire on an innocent sentence, which is why it can be switched off and why every row quotes its source. If the same fix has to be applied across a document rather than pulled out of it — every old address swapped for a new one, say — the find and replace tool does that in one pass with a preview of each change.

The document you paste stays on your own machine

People paste sensitive things into this box: client threads, applicant details, supplier contracts, membership lists. None of it moves. This page is a static file with no back end behind it, and the finding, the unscrambling and every one of the shape checks run in JavaScript that reached your computer before you pasted anything. Nothing is uploaded, nothing is logged, no address is looked up against any list, and no request leaves your browser when you press a button.

That is also why no result here can tell you whether a mailbox is real — doing so would mean sending your addresses to a server, and this page has nowhere to send them. Close the tab and the text is gone; it is not saved, not cached and not restored on your next visit.