Email Permutator for Google Sheets: The Formula, the Template, and the Honest Limits

An email permutator builds every likely email address from a person’s name and their company domain. It doesn’t find anything. It guesses, in bulk, using the naming rules companies actually follow. And the formulas that do the guessing are sitting a few paragraphs below this one, free and copy-paste ready.

I’m going to be honest with you. In 2020 I permuted a 400-row webinar list and sent it the same week without verifying a single address. It went badly, and I’ll tell you exactly how badly further down.

So if you came looking for an email permutator Google Sheets template you can actually paste into a tab, that’s what’s here, plus the discipline that keeps it from wrecking your sending domain. Let’s get into it.

📌 TL;DR: An email permutator takes a first name, a last name and a mail domain, then writes out every likely address: first.last@, f.last@, firstlast@ and nine more. One ARRAYFORMULA does all twelve across a row, and you drag it down the list. Then verify before you send: syntax → MX → mailbox. And when 500 rows turn into 6,000 guesses, stop guessing and look the addresses up instead.

What Is an Email Permutator?

An email permutator is a tool that generates every likely email address from a name and a company domain. It produces candidates. Not contacts, not verified addresses. Candidates. That difference is the whole article, so I’ll keep repeating it.

It never looks anything up, either. Real contact data lives in databases, inboxes and signatures. A permutator just manufactures plausible strings and hands them to you.

So why do the patterns exist at all? Because nobody hands out addresses at random. Somebody in IT picked a rule on day one, usually first.last@, and every hire since has been stamped with it. If you know the rule, you know the address. If you don’t, you guess the rule and test the guesses.

The piece before the @ has a proper name: the local part. That’s the bit an email address permutator invents. The domain after the @ you already have, or you go and find it.

Four inputs, then. That’s all a permutator needs:

• A first name.
• A last name.
• The company’s MAIL domain, which isn’t always the website domain.
• A set of patterns to try.

And that third input is where most permutation projects quietly die. More on that shortly. First, the part you came for.

The Email Permutator Formula You Can Copy Into Google Sheets

Four formulas below. A one-cell version, a readable version, a pattern applier, and a shape check. Take whichever fits your list. Every email permutator Google Sheets build starts from the same four columns, so set those up first.

Set Up Four Columns First

Column A: first name. Column B: last name. Column C: the mail domain, written bare as company.com with no https and no www. Column D onward: candidates. Row 1 holds your headers, so every formula here starts on row 2.

Names arrive dirty. Trailing spaces, capitals, accents, hyphens. TRIM and LOWER handle the first two on their own, but accented characters need a decision from you. Because “Müller” becomes either “muller” or “mueller” depending on the company, and both are common in German-speaking markets.

So build two cleaning columns and generate both spellings. This one strips the accent down to the bare letter:

=LOWER(TRIM(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(B2,"ü","u"),"ö","o"),"ä","a"),"é","e"),"ñ","n"),"ß","ss")))

Müller comes out as muller. Nested SUBSTITUTE calls just run one replacement after another, so add pairs for whatever accents your list actually contains. And this second one produces the transliterated spelling instead:

=LOWER(TRIM(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(B2,"ü","ue"),"ö","oe"),"ä","ae"),"ß","ss")))

Now Müller comes out as mueller. Run both, permute both, verify both. Hyphenated surnames get the same treatment: some companies keep the hyphen in the address, others drop it, so wrap another SUBSTITUTE around your clean column that swaps “-” for nothing and test that version too.

The One-Cell Version (12 Candidates Across the Row)

Paste this into D2. It fills D2 through O2 with twelve candidates, and you drag it down the whole list:

=LET(f,LOWER(TRIM($A2)),l,LOWER(TRIM($B2)),d,LOWER(TRIM($C2)),ARRAYFORMULA({f&"."&l,f&l,f&"_"&l,f&"-"&l,LEFT(f,1)&"."&l,LEFT(f,1)&l,f,l,f&LEFT(l,1),f&"."&LEFT(l,1),l&LEFT(f,1),l&"."&f}&"@"&d))

Here’s what it’s doing, in plain words. LET names three cleaned values once (f for the first name, l for the last name, d for the domain) so the rest of the email permutator formula stays readable. The curly braces then hold twelve patterns side by side, and ARRAYFORMULA spills them across twelve columns instead of jamming them into one cell.

Those twelve come in five families:

• Full name, four separators: first.last, firstlast, first_last, first-last.
• Initial plus surname: f.last and flast, the second most common corporate rule I meet.
• Single name: first and last, which small companies and founders use a lot.
• Name plus initial: firstl and first.l.
• Reversed: lastf and last.first, rare but real, especially in older European systems.

One locale note, because this trips people up. The formula above uses US-English separators. In locales that use a comma as the decimal separator, the argument separator becomes a semicolon and the column separator inside the curly braces becomes a backslash. Same formula, different punctuation.

The Readable Version (One Pattern Per Column)

Some people hate one-cell magic. Fair enough. Here’s the same job as five plain formulas that go, top to bottom, into D2, E2, F2, G2 and H2:

=LOWER(TRIM($A2)&"."&TRIM($B2)&"@"&TRIM($C2))
=LOWER(TRIM($A2)&TRIM($B2)&"@"&TRIM($C2))
=LOWER(LEFT(TRIM($A2),1)&"."&TRIM($B2)&"@"&TRIM($C2))
=LOWER(LEFT(TRIM($A2),1)&TRIM($B2)&"@"&TRIM($C2))
=LOWER(TRIM($A2)&"@"&TRIM($C2))

That’s first.last, firstlast, f.last, flast and first, in order. Each column now holds exactly one pattern, so you can sort by it, filter it, delete a whole pattern that never lands in your market, and keep track of which guess produced which result. Slower to set up. Much easier to reason about later.

The Pattern Applier (My Favourite One)

This is the formula nobody puts on a free email permutator page, and it’s the one that saves my week.

Here’s the idea. You find ONE real address at a company: off their press page, from a support reply, in a webinar signature. That single address tells you the company’s rule. So instead of generating twelve guesses for all forty of their employees, you record the rule once and apply it to everyone.

Put the pattern name in column D (“first.last”, “flast”, “f.last”, and so on). Then drop this into E2:

=LET(f,LOWER(TRIM($A2)),l,LOWER(TRIM($B2)),d,LOWER(TRIM($C2)),p,LOWER(TRIM($D2)),x,SWITCH(p,"first.last",f&"."&l,"firstlast",f&l,"f.last",LEFT(f,1)&"."&l,"flast",LEFT(f,1)&l,"first_last",f&"_"&l,"first",f,"last.first",l&"."&f,""),IF(x="","",x&"@"&d))

SWITCH reads the pattern name in column D, matches it against the seven rules listed inside, and builds the matching local part. The final IF is a small kindness to yourself: if column D is empty or holds a pattern you haven’t defined, the cell stays blank instead of writing a broken address like “@company.com”.

Type the pattern once, drag column D down for everyone at that company, and column E fills with addresses built from a rule you confirmed. That’s not guessing anymore. That’s applying.

But still verify. Big organisations often run two rules at once after a merger, and the pattern you confirmed might only cover half the building.

A Shape Check Column

Before anything goes near a verifier, filter out the junk. This flags malformed candidates, assuming your addresses sit in column E:

=IF($E2="","",IF(AND(COUNTIF($E2,"?*@?*.?*")=1,COUNTIF($E2,"* *")=0,COUNTIF($E2,"*@*@*")=0,COUNTIF($E2,"*..*")=0),"ok","check"))

COUNTIF treats ? as any single character and * as any run of characters, so “?*@?*.?*” means: something, an @, something, a dot, something. The other three tests catch the classics: a space inside the address, a double @, a double dot. Those are exactly what a missing first name or a stray comma in your source file produces.

Filter the column to “check”, fix those rows, and only then spend money verifying.

💡 Pro Tip: Before you generate twelve guesses for a company, spend five minutes hunting ONE real address at that company: press page, support inbox, a reply in your CRM. One confirmed address plus the SWITCH formula beats a thousand permutations, every time.

Working in Excel rather than Sheets? The permutator logic is identical, but the array syntax and the round-trip differ, and the email lookup in Excel guide covers that path.

How Do You Verify Permutated Emails Before Sending?

Run three checks in order: syntax, then the mail domain’s MX records, then the individual mailbox. Skip any of the three and you’re back to sending guesses.

Syntax is the shape check you just built. It costs nothing and it removes the obvious wreckage.

Next comes the domain. An MX record is the DNS entry that says where a domain’s mail should be delivered, and no MX record means no mailbox can exist there at all. Paste the domain into the Google Admin Toolbox MX check and you’ll see in seconds whether that domain receives mail and who runs it.

Then the mailbox itself, which is what proper Data Verification adds on top. A verifier opens a conversation with the receiving server and asks whether that specific address exists. Useful, but not absolute: the SMTP standard lets servers answer those questions vaguely, and plenty of them do exactly that on purpose.

Which brings up the honest ceiling. A Catch-All Email domain accepts mail for ANY address you throw at it. So on a catch-all, “accepted” proves nothing whatsoever. Your twelve guesses will all come back green, and eleven of them are still wrong.

Now the mistake that cost me a whole afternoon. I once permuted sixty addresses for a mid-size brand using the domain printed on their website. Every single one bounced. Their mail actually ran on the parent group’s domain after an acquisition, and the website domain had no mailboxes behind it at all. Two minutes in the MX checker would have told me that before I generated a single guess.

So check the mail domain first. Always. It’s the cheapest step in the whole workflow.

📌 Example: That 400-row webinar list, two runs. Permuted and sent unverified → 14% bounce rate and about a month of repair work. Same list verified the following quarter → under 1%. The names never changed. My patience did.

When Does Email Permutation Stop Working?

Permutation stops working on catch-all domains, consumer inboxes, random local parts, and any company running several patterns at once. Here’s the full honest list:

• Catch-all domains. Everything is accepted, so nothing is confirmed.
• Consumer domains. Gmail, Outlook, Yahoo addresses have no company rule to reverse-engineer. People pick them personally, and there’s no pattern to find.
• Employee IDs and random local parts. Some enterprises use m4471@ or a hashed string. No permutator on earth guesses that.
• Duplicate names. Two Anna Schmidts in one company means one of them is anna.schmidt2@ or a.schmidt@, and your guess lands in the wrong inbox.
• Post-merger organisations. Legacy staff on one rule, new hires on another, both live at once.
• Hyphenated and accented surnames. The silent match killer in European lists, and the reason you built two cleaning columns.

Then there’s the arithmetic, which is the part I wish someone had shown me in 2020.

→ 500 rows → 12 candidates each → 6,000 addresses you now have to verify → to find roughly 500 real ones.

Verification is the part you pay for, and you’d be paying for 6,000 checks to keep 500 addresses. That’s the stop sign. Past a few dozen rows, permutation isn’t the cheap option anymore, it just feels like it because generating guesses is free.

And the cost of getting it wrong isn’t only money. Every invalid address you send to becomes a Hard Bounce, mailbox providers count those against your domain, and your Email Deliverability is not something you can buy back in an afternoon. Mine took a month.

How Do You Skip the Guessing and Look the Email Up Instead?

You run an add-on that matches each row against a contact database and writes verified addresses back. No twelve columns of maybes. One column of answers, and blanks where there’s no answer.

Here’s the whole loop:

1. Install the add-on. Get the CUFinder add-on from the Google Workspace Marketplace. If add-ons are new to you, Google’s help page explains how they install and where they turn up.
2. Copy your API key. Open the CUFinder dashboard and copy the API key from there.
3. Enter the key in the add-on. Paste it once and you’re connected.
4. Pick the service. Open the add-on from the Google Sheets menu and it opens as a right panel listing all the enrichment services. Your input decides the pick: name plus company columns → Contact Enrichment, which will find a professional email by name and company. A LinkedIn URL column → the service that returns a work email from a LinkedIn URL.
5. Map columns, set the range, run. Set the input column, set the output column where the emails should land, and specify the row range: rows 2 to 6 for a test, rows 2 to 500 for the real list. Then run it.

One honest expectation before you start. Some rows come back empty, because no provider matches every person alive. But an empty cell is information, and a guess pretending to be an address is not. A blank beats a guess.

That’s also the difference between this and the permutator tab you just built. I still keep the permutator for one-off accounts where I have a confirmed pattern. For anything past fifty rows, I run the lookup, the same reasoning I walked through in the email finder in Google Sheets guide.

A Worked Example: 5 Rows, Before and After

Let’s make this concrete. Five people, their mail domains already checked, and an empty column D:

	A	B	C	D
1	First name	Last name	Mail domain	Verified email
2	Anna	Müller-Schmidt	nordwind-textil.de
3	Diego	Costa	costamarine.com
4	Ruth	Adeyemi	corvidanalytics.com
5	Jan	Novak	tidewaterrobotics.com
6	Clara	Bennett	hansellogistics.com

Then I picked Contact Enrichment in the panel, set the input to the name and domain columns A, B and C, set the output to column D, and specified the row range 2 to 6. A minute later the same tab looked like this:

	A	B	C	D
1	First name	Last name	Mail domain	Verified email
2	Anna	Müller-Schmidt	nordwind-textil.de	anna.mueller-schmidt@nordwind-textil.de
3	Diego	Costa	costamarine.com	d.costa@costamarine.com
4	Ruth	Adeyemi	corvidanalytics.com	ruth.adeyemi@corvidanalytics.com
5	Jan	Novak	tidewaterrobotics.com
6	Clara	Bennett	hansellogistics.com	clara.bennett@hansellogistics.com

Look at row 2. Anna’s address uses the transliterated “mueller” spelling AND keeps the hyphen: two decisions my permutator would have had to guess at, and it would have got at least one of them wrong.

Row 5 came back blank. No verified match for Jan, so nothing was written. That’s the honest output I actually want, because a blank cell tells me to research one person instead of quietly poisoning a send.

→ 5 names → 12 guesses each → 60 unverified sends → OR one verified column, four addresses and one visible gap. The second version is the one your cold outreach list deserves.

Feeding domains rather than people? That’s the bulk email finder route. And if the sheet already holds addresses that just need titles, phones and company data attached, that’s an email list enrichment job instead.

What Mistakes Should You Avoid With an Email Permutator?

The big ones: sending the whole guess list, trusting a catch-all accept, and permuting consumer addresses. I’ve done all three, so treat this as a scar map:

• Sending every permutation to see what sticks. Twelve emails to one person is not a clever test, it’s a spam report waiting to happen. Verify, then send to ONE address.
• Treating a catch-all “accept” as verification. The domain accepts everything, so your green ticks mean the server is polite, not that the mailbox exists.
• Permuting consumer addresses. There’s no company rule behind a personal Gmail account, so every candidate is a coin flip.
• Using the website domain when mail runs elsewhere. Check the MX records before you generate anything. Ask me how I know.
• Forgetting accented and hyphenated variants. One missing SUBSTITUTE quietly wipes out a chunk of any European list.
• Ignoring consent rules. Under GDPR you need a lawful basis such as legitimate interest, plus an easy opt-out. The CAN-SPAM Act wants honest headers, a physical address and a working unsubscribe link. A guessed address doesn’t excuse you from either.

Every one of those mistakes lands in the same place, by the way: your Sender Reputation. And that’s the account you can’t top up with a credit card.

🔍 Did You Know? Google's bulk sender guidelines cap spam complaints at 0.3% (three per thousand emails). One unverified permutation batch can push you past that in a single morning.

You’ll find that threshold spelled out in Google’s own sender guidelines, and it applies whether you send a hundred emails or a hundred thousand.

FAQ: Email Permutators in Google Sheets

What is an email permutator?

An email permutator generates every likely email address from a person’s name and their company domain. It combines first names, last names and initials with common corporate patterns, then hands you a list of candidates. None of them are confirmed. Verification is a separate step, and it’s the step that decides whether the guesses were any good.

Is there a free email permutator?

Yes, and you just built one. The formulas above cost nothing and run inside a spreadsheet you already own. Plenty of free web permutators exist too. What nobody gives away free is verification, because checking whether an address actually receives mail means talking to real mail servers at scale.

Are there email permutator Chrome extensions?

Yes, several browser extensions generate permutations while you browse a company site or profile. They’re convenient. The trade-offs are real, though: most ask for broad page-reading permissions, and the output is exactly as unverified as a spreadsheet formula. Same guesses, fewer clicks, more access to your browsing.

Does an email permutator work for Gmail addresses?

No, not in any reliable way. Company patterns exist because an administrator set a rule for everyone. Personal Gmail, Outlook and Yahoo addresses are chosen by the individual, so there’s no rule to reverse-engineer. Permuting consumer addresses produces noise and burns verification budget for nothing.

Can you build an email from a phone number?

No. A phone number and an email address are unrelated identifiers, issued by different systems with no shared logic between them. Permutation works only on name plus domain. If you have a phone number and want the matching email, that’s a database lookup on the person, not a formula.

How accurate are permutated email addresses?

Accuracy depends entirely on how predictable the company’s pattern is. At a firm using plain first.last@, your top guess lands often. At a company using employee IDs or running two patterns after a merger, it barely lands at all. Until a verifier confirms it, every candidate is a guess.

How much do email finder tools cost compared with permutating?

Generation is free either way; the paid parts are verification and database lookups. Most email finders sell credits, and one credit usually covers one lookup. So compare cost per verified address, not cost per search. A cheap tool with a low match rate can end up costing more per usable contact.

What is the email address extractor in Google Sheets?

That’s a different job. An extractor pulls addresses out of text you already have, using a formula like REGEXEXTRACT with an email pattern against a cell of messy notes. A permutator creates addresses that might exist. Extract when the data is already in your sheet; permute when it isn’t.

It’s Time to Build Your Permutator Tab

You’ve got the whole kit now. Four clean columns, an email permutator formula that fills twelve candidates in one paste, a SWITCH applier for companies whose rule you’ve confirmed, and a shape check that keeps junk away from your verifier.

Picture the next twenty minutes. New tab, headers in row 1, formula in D2, drag it down. MX check on the domains. Verify what’s left. Then send to the verified subset only, and go do something else while the replies come in. That’s my routine now, and it started with the same email permutator Google Sheets tab you’re about to build.

Emails are only the first column, though. The rest of the data enrichment in Google Sheets hub covers what to add next: job titles, phone numbers, company size, all of it. So tell me in the comments: which company’s email pattern has been driving you mad?