Guides for developers and growth teams on signup fraud, disposable email, telling business from personal addresses, and enriching leads from a domain.
How to pick an email verification API: accuracy, catch-all handling, pricing model, API design, integrations and data handling, plus a test plan you can run.
Put a small serverless function between your website form and your CRM: verify each lead's email, push real leads with their status, and keep junk out.
Node.js 18+ code to verify email addresses with built-in fetch: one address, chunks of 50 through a batch endpoint, and retry with backoff on HTTP 429.
Python code to verify email addresses with requests: one address, batches of 50, 429 handling with Retry-After and backoff, and a CSV in, CSV out script.
What each email verification status and reason code means, which ones you can trust, and what to do with the address: send, suppress, segment or retry.
How email typo detection works, why gmial.com passes every format check, and the UI copy that gets people to fix the address without silently changing it.
A practical cleaning schedule by list type: verify at entry, re-check before big sends and sequences, and react to bounce and complaint signals in between.
How Gmail, Google Workspace and Microsoft 365 answer mailbox checks, why some tenants accept every address, and how to read risky and unknown results.
How email verification fits GDPR: lawful basis, legitimate interest, data minimisation and processor contracts, plus what pingutil stores and for how long.
Verify new Pipedrive contacts automatically: a webhook on person create calls an email verification API and writes the result to a custom field via the Pipedrive API.
Greylisting makes mail servers temporarily refuse unknown senders, so verifiers get a 4xx instead of an answer. What RFC 6647 says and how to handle unknown results.
What accuracy claims from email verifiers usually measure, why catch-all and unknown results exist, and how to test a verifier's accuracy on your own list.
Export your Mailchimp audience, verify the addresses by CSV upload or batch API, then tag and archive the bad ones using Mailchimp's own import and archive tools.
Catch typos, throwaway addresses and dead mailboxes in webinar and event signups before the confirmation and reminder emails go out, without adding friction.
Timeouts, retries, caching, rate limits and what to do with unknown results: the checklist for wiring an email verification API into signup, CRM and outbound tools.
Check signup emails on blur in React 19: catch typos, disposable domains and role addresses with clear messages, a backend proxy and no blocking on failures.
Verify new leads in a Zap: POST each address to an email verification API with Webhooks by Zapier, then filter or branch on valid, risky, invalid and unknown.
Build an n8n workflow that classifies each new signup's email as company, webmail, disposable or role-based and routes it, plus a deduped nightly batch.
Bad addresses waste sequence steps, rep time and sending reputation. A worked example with hypothetical numbers shows how to estimate the cost on your own list.
Pristine, recycled and typo spam traps explained, why no verifier can reliably flag them, and the list hygiene habits that keep you off blocklists.
Clean an exported lead list before importing it into a sequencer: dedupe, verify every address, split by result, and keep risky contacts out of the main sequence.
Real-time email verification checks one address as it is entered; bulk verification cleans a list before a send. When to use each, and why most teams need both.
What to remove from a newsletter list before a send: disposable and dead domains, provider typos, system addresses and sometimes role addresses. With a script.
Verify email at signup in real time: catch typos with a did-you-mean prompt, block only what is certainly bad, and warn instead of blocking on everything else.
Work email addresses die when people change jobs and companies change domains. How B2B email list decay happens, how to spot it, and a re-verification cadence.
Invalid addresses cause hard bounces and spam trap hits, which providers read as a sign of a bad list. What Gmail, Yahoo and SES say, and how to fix it.
Use a HubSpot workflow's Send a webhook action to classify each new contact's email domain and write category, spam verdict and company fields to the record.
Verify Salesforce lead emails automatically: a named credential, a Queueable Apex callout to a verification API, and status fields your reps can filter on.
Verify contact emails in HubSpot automatically: a workflow custom code action calls an email verification API and writes the status to a contact property.
Hard bounces are permanent 5xx failures, soft bounces are temporary 4xx ones. How to read SMTP and enhanced status codes, and which addresses to suppress.
A good email bounce rate is under 2% of hard bounces. Here is where that number comes from, which providers publish limits, and what drives bounces up.
Why to verify a prospect list before it enters a sequence, how to sort valid, invalid, risky and unknown results, and what to do with each bucket.
Card testing is stopped mainly by payment-side controls: rate limits, CAPTCHA, Radar-style rules and 3DS. Email signals help with the fake accounts around it.
A dependency-free Python script that dedupes a CSV of emails, classifies each domain, drops disposable and invalid addresses, and respects API rate limits.
What a domain intelligence API should return, exactly what pingutil gives you (fields and rate limits), what it doesn't do, and how it compares with free tiers elsewhere.
An Apps Script that tags every email in a Google Sheet as company, free, disposable, ISP or education, with throttling, domain dedupe and a safely stored key.
Tag every signup as real, suspect, fake or internal when the account is created, then filter on that tag in PostHog, Mixpanel, Amplitude or plain SQL.
Reject disposable and machine-generated signup emails in an Auth0 pre-user-registration Action, with secrets, a timeout, 429 backoff and fail-open logic.
Branch onboarding on the signup email domain: team setup for company addresses, a solo flow for Gmail, an education plan for .edu. Code, UX copy and privacy rules.
Use Supabase's Before User Created hook and an Edge Function to reject disposable and machine-generated emails at signup, with timeouts and fail-open handling.
A transparent points-based lead scoring model from email category, company size, industry and email signals, with starting weights and a calibration method.
Screen signup emails in a Cloudflare Worker before they reach your origin: secrets, timeouts, 429 backoff and fail-open forwarding, with complete code.
Put a small webhook between Tally or Typeform and your CRM: verify the signature, classify the submitter's email, and route real leads to the CRM and junk to review.
Check signup emails for disposable and machine-generated addresses inside a Next.js server action, with timeouts, 429 backoff and a clear fail-open policy.
Use the Auth.js v5 signIn callback to block disposable and machine-generated emails for magic-link and OAuth sign-ins, with caching and fail-open handling.
Call the pingutil domain lookup API from curl, JavaScript, Python and Go, with timeouts, 429 handling and the fields you should actually read.
Reject disposable and machine-generated emails in Firebase Auth with a beforeUserCreated blocking function: setup requirements, full code, timeouts and fail-open.
A practical email risk score for signups: which signals to use, hard rules vs points, score bands, and how to calibrate it against your own abuse data.
A Go signup check with net/http, context timeouts, typed structs, an ICANN-only eTLD+1 helper built on x/net/publicsuffix, a TTL cache and fail-open 429 handling.
A signup domain that receives mail but has no website is a useful fraud signal, not a verdict. What DNS shows, the innocent cases, and how to score it.
A Rails EachValidator that rejects disposable, machine-generated and optional free webmail emails, with Net::HTTP timeouts, Rails.cache and fail-open logic.
A catch-all domain accepts mail for any address, so verifiers can't confirm a mailbox. How detection works, why it's common in B2B, and how to treat it.
A Laravel ValidationRule that rejects disposable, machine-generated and (optionally) free webmail addresses, using the Http facade with timeouts, retry and caching.
Why jane.doe+trial2@gmail.com and janedoe@googlemail.com are one inbox, and how to build a canonical email key that catches duplicates without breaking login.
Block disposable and machine-generated emails at WordPress and WooCommerce registration with the registration_errors filter, a short timeout and fail-open logic.
What an SMTP mailbox probe really tests, the six ways its answers mislead you (VRFY, catch-all, greylisting, port 25 blocks), and what to use instead.
No: @gmail.com is free personal webmail, even when a business uses it. Google Workspace on a custom domain is business. How to tell them apart in code.
Handle addresses like jane@bücher.de: convert the domain to punycode with UTS 46, leave the local part alone, and avoid the traps that split one domain in two.
Check if an email is disposable by hand (public blocklist, MX lookup, a quick search) or in code with a list or an API. Includes a short checklist.
Run MX, A and AAAA lookups from edge functions and serverless runtimes with the Cloudflare and Google DoH JSON APIs: request format, status codes and gotchas.
Plain definitions of 40 email and domain intelligence terms, from catch-all and null MX to eTLD+1, RDAP, SPF and DMARC, with links to deeper guides.
How to tell from DNS whether a domain accepts mail: MX lookups, the implicit MX fallback, null MX, and which DNS errors should never block a signup.
Which lead qualification steps an LLM is good at, which ones a deterministic lookup should own, and a pipeline that puts each in the right place.
A regex can only tell you an email address is shaped right. What to match, what to deliberately reject, and the checks a pattern can never replace.
Tool definitions for Anthropic tool use, OpenAI function calling and MCP that let an LLM agent classify emails and domains with a real API, key kept server-side.
Validation checks that an address could work. Verification proves someone receives mail there. What each layer catches, misses, and where it belongs.
SPF and DMARC show whether a domain's owner set up outbound mail authentication. How to look them up over DNS, what they prove, and what they don't.
Detect teammates who sign up separately: group signups by registrable domain, skip webmail and schools, then send a team invite or a sales alert.
How to check a signup domain's registration age with RDAP, when a young domain means risk, the innocent cases, and how to combine it with a domain lookup.
What eTLD+1 means, how the Public Suffix List defines it, why splitting on dots breaks on bbc.co.uk, and how to compute it in JavaScript, Python and Go.
RDAP replaced WHOIS for generic TLDs in 2025. How the two protocols differ, how to query RDAP in code, and where you still need WHOIS for country-code domains.
How to cache email and domain lookup results: what to key on, which fields can share a cache entry, TTLs per data type, stale-on-error, and when to force a refresh.
Verification services check if a mailbox will accept mail. Classification APIs tell you what kind of address it is. Which job needs which, and when to use both.
Where AI company enrichment is reliable, where it fails (invented funding, stale HQs, the wrong company), and the guardrails that make it safe to use.
Free and low-cost domain lookup tools grouped by the question they answer: registration (RDAP, WHOIS), DNS, domain type and company data, with commands you can run now.
Clean up a CRM by email domain: normalize company domains, merge duplicate accounts, separate personal and disposable contacts, and keep it clean.
Disposable email detection tools by type: open lists, libraries, keyless endpoints, APIs and web checkers, with list sizes and the trade-offs of each.
Build lead routing rules on enriched company size, industry and country: segment buckets, an ordered rule table, confidence gates and a triage queue for unknowns.
Free tiers of ZeroBounce, Abstract, Hunter, MailboxValidator, Emailable and Kickbox compared: quotas, resets, SMTP checks, and where a usage-based API like pingutil fits.
Design a lead enrichment step that starts from a work email: gate by domain type, enrich async, record provenance, never overwrite human input.
What changed at Clearbit after HubSpot bought it, which features are gone, and a replacement for each one: logos, enrichment, form shortening and signup screening.
Budget company enrichment comes in three forms: capped free tiers of paid databases, low-cost LLM-generated profiles, and DIY scraping. What each returns, and how to test them.
Domain intelligence is everything you can learn about a domain name: what kind of domain it is, whether it works, who registered it and which company is behind it.
A country-by-country guide to government email domains: what .gov, gov.uk and gouv.fr rules catch, what they miss (gc.ca, bund.de, go.jp), with detection code.
How to check if an email belongs to a university or school: TLD rules that work, the countries they miss, a university domain list, and a verification flow.
comcast.net, btinternet.com and orange.fr are consumer ISP mailboxes. Why they break lead enrichment and routing, which domains to list, and how to treat them.
Role-based addresses like info@ and support@ are shared inboxes, not people. When to accept, flag or reject them, and how to detect them without false hits.
Turn an email address into a company name: normalize the domain, discard webmail and ISP domains, then resolve the rest from its website or an enrichment API.
When a work-email-only signup helps a B2B funnel, when it quietly costs you customers, and how to ask for a work email without rejecting anyone.
The webmail domains worth listing, grouped by provider and region, why 30,000-domain lists answer a different question, and how to tune a list to your users.
Classify an email as business or personal: reduce to the registrable domain, check provider lists, then use MX records to catch personal custom domains.
A decision framework for disposable email at signup: which surfaces deserve a hard block, when to flag instead, and what a flag should do to the account.
Open blocklists, free hosted endpoints, paid verification APIs and domain intelligence APIs compared on cost, latency, freshness and failure modes.
Referral abuse is one person posing as many. The email signals that link those fake referees together, with code that scores a referrer before you pay out.
How to spot bot-made addresses like xk7qmz2p@gmail.com from the local part alone: the features that work, a runnable scorer, and where it flags real people.
Relay addresses look random but forward to a real, long-lived inbox. Why they differ from disposable email, why filters misfire on them, and how to allow them.
Fake SaaS signups come from five different sources, and each needs a different filter. How to tell which one you have, and what to put in front of each.
A practical playbook for SaaS founders: screen signup emails, dedupe identities and gate trial value in steps, so abusers stall and real users never notice.
The open disposable domain list doubled in a year. Why vendored copies decay, how lists also gather bad entries, and a safe update process with code.
Block disposable email signups in Django and FastAPI with one shared validator, the PyPI blocklist package, offline PSL matching and a fail-open API option.
Express 5 middleware that blocks disposable email signups using a self-refreshing open blocklist or a single API call, with tests and fail-open handling.
Four layered checks that catch disposable email at signup: domain normalization, an updating blocklist, MX fingerprinting and DNS signals, with working code.
What disposable email addresses are, how services like Mailinator work, who uses them, and a simple rule for deciding whether your product should block them.