// guide
How to stop fake and throwaway signups in your SaaS app
For saaS founders, indie hackers and backend developers who own the signup flow · Updated · 7 min read
Half the accounts created this week are junk, and I can't tell which half until they've already burned resources.
To stop fake and throwaway signups, check every email address on the server before the account exists. One pingutil lookup with skip_enrichment: true returns a verdict in milliseconds: reject when verdict.is_spam is true (disposable domain or machine-generated address), send verdict.low_trust accounts to review, and let everyone else straight through. Real users never see the check.
This guide is for the person who owns the signup endpoint and is tired of cleaning up after it. It covers what fake accounts cost, the exact check to add, how to act on each field, and where the check stops helping.
What this problem costs you
Fake signups look harmless on a dashboard. They show up as a slightly better week. The cost lands elsewhere:
- Infrastructure. If a new account gets LLM credits, compute, storage or outbound email, every fake account is a line on your bill. Scripted signups multiply that by however many identities the script can mint.
- Deliverability. Welcome emails and onboarding sequences sent to throwaway inboxes that expire an hour later turn into bounces. Bounce rate is one of the signals mailbox providers use to judge your sending domain, and that domain also carries password resets for your real customers.
- Bad numbers. Activation rate, trial conversion and funnel reports all count fake accounts as real people who didn't convert. You end up tuning onboarding for users who never existed. Keeping fake signups out of analytics covers that side.
- Support and abuse. Fake accounts are where spam, scraping and promo abuse start. Every one you let in is a cleanup ticket later.
None of this needs a statistic to be true for your product. Look at your last 100 signups and count the @mailinator.com, @10minutemail and xk7qpz93@ addresses. That number is your baseline.
Where fake signups come from
Three patterns cover most of what you'll see. Fake signups in SaaS goes through them in more detail.
| Pattern | What the email looks like | Cheapest signal |
|---|---|---|
| Throwaway inbox | anything@ a disposable provider domain |
Domain is on a disposable list |
| Scripted account farm | ccjxx90sze@gmail.com, lomigi6768@outlook.com |
Local part is machine-generated |
| Low-effort human | test@test.com, admin@ their own domain |
Role or system address, domain that doesn't resolve |
The first two are what verdict.is_spam is built for. The third is a judgment call, which is why it gets a softer flag.
How pingutil solves it
1. Get an API key
Sign in at the dashboard (passwordless) and create a key. It starts with pk_live_ and is shown once, so put it straight into your secrets manager. Before you write any code, paste a few of your recent junk addresses into the live demo to see what the API returns for them.
2. Call the lookup endpoint before you create the user
Call POST https://pingutil.com/v1/lookup from your backend with the email as input. Set skip_enrichment: true: you don't need a company profile to decide whether an address is junk, and skipping the LLM step keeps the call fast. Add check_dns: true if you also want to know whether the domain exists and can receive mail.
Do this server-side. A check in the browser is nice for user feedback, but bots post straight to your API.
3. Act on the verdict
The response has a verdict object with three fields: is_spam, low_trust and reason. That's the whole decision for most products.
4. Store the result with the account
Write category and verdict.reason to the user record. When you later look at which accounts abused a trial or never activated, you'll be able to see whether the signal was there at signup.
Decision table: response field to action
| Field and value | What it means | Recommended action |
|---|---|---|
verdict.is_spam: true, reason: "disposable_domain" |
Domain is on the disposable list (about 9,900 domains, re-synced weekly) or flagged by reputation check | Reject with a plain message asking for a permanent address |
verdict.is_spam: true, reason: "randomized_local_part" |
Local part looks machine-generated (ccjxx90sze@) |
Reject, or require email confirmation before any resources are granted |
verdict.low_trust: true, reason: "role_based" |
info@, support@, admin@ and similar |
Allow, but flag for review or ask for a personal address on paid features |
verdict.low_trust: true, reason: "system_generated" |
noreply@, mailer-daemon@, bounce@ |
Reject. Nobody reads that inbox |
verdict.low_trust: true, reason: "sales_outreach" |
sales@, marketing@, outreach@ |
Allow, low priority. Often a vendor, not a user |
domain_signals.domain_exists: false |
Domain doesn't resolve (requires check_dns: true) |
Reject. Mail to it can't arrive |
domain_signals.can_receive_email: false |
No MX and no A record fallback | Reject or ask the user to check for a typo |
category: "free", verdict clean |
Personal webmail like Gmail | Allow |
category: "company", verdict clean |
Custom domain | Allow. Consider personalizing onboarding |
category: "unknown" |
Input couldn't be parsed | Reject as invalid email |
Two choices here are deliberate. Role addresses aren't blocked because small companies really do sign up with hello@ their domain. And domain_signals never changes verdict, so blocking on DNS is your policy to apply, not something the API does for you.
Complete example: Express signup handler
This is a full Node.js 18+ handler. It fails open: if pingutil is unreachable or you've hit a limit, the signup proceeds and is marked unscreened, so an outage on our side never blocks your real users.
// signup.mjs (Node 18+, Express)
import { randomUUID } from 'node:crypto';
import express from 'express';
const app = express();
app.use(express.json());
const PINGUTIL_KEY = process.env.PINGUTIL_KEY; // pk_live_...
async function screenEmail(email) {
const controller = new AbortController();
const timer = setTimeout(() => controller.abort(), 3000);
try {
const res = await fetch('https://pingutil.com/v1/lookup', {
method: 'POST',
headers: {
authorization: `Bearer ${PINGUTIL_KEY}`,
'content-type': 'application/json',
},
body: JSON.stringify({ input: email, skip_enrichment: true, check_dns: true }),
signal: controller.signal,
});
if (res.status === 400) return { decision: 'reject', reason: 'invalid_email' };
if (!res.ok) return { decision: 'allow', reason: 'unscreened', data: null };
const data = await res.json();
return { decision: decide(data), reason: data.verdict.reason, data };
} catch {
return { decision: 'allow', reason: 'unscreened', data: null };
} finally {
clearTimeout(timer);
}
}
function decide(data) {
if (data.category === 'unknown') return 'reject';
if (data.verdict.is_spam) return 'reject';
if (data.verdict.reason === 'system_generated') return 'reject';
if (data.domain_signals && !data.domain_signals.domain_exists) return 'reject';
if (data.domain_signals && !data.domain_signals.can_receive_email) return 'reject';
if (data.verdict.low_trust) return 'review';
return 'allow';
}
app.post('/signup', async (req, res) => {
const email = String(req.body.email ?? '').trim();
if (!email) return res.status(400).json({ error: 'Email is required.' });
const screen = await screenEmail(email);
if (screen.decision === 'reject') {
return res.status(422).json({
error: 'Please sign up with a permanent email address you can receive mail at.',
});
}
const user = await createUser({
email,
signupCategory: screen.data?.category ?? null,
signupReason: screen.reason,
needsReview: screen.decision === 'review',
});
res.status(201).json({ id: user.id });
});
async function createUser(fields) {
// Replace with your database insert.
return { id: randomUUID(), ...fields };
}
app.listen(3000);
Keep the rejection message generic. Telling a script exactly which rule it tripped helps it route around you.
Edge cases and limits
Be clear-eyed about what this check does and doesn't do.
- Blocklists lag. New disposable domains appear constantly. The list is re-synced from the community disposable-email-domains project every Monday, but a domain registered yesterday may not be on it yet. Why blocklists go stale explains the gap.
- Privacy relays can look random. Apple Hide My Email, Firefox Relay and SimpleLogin aliases are real, forwarding addresses, but their local parts can trip the randomness check. If your audience skews privacy-conscious, consider treating
randomized_local_parton those relay domains as review instead of reject. See relay services vs disposable email. - Some real names score as random. The randomness model includes an international first-name dictionary, but unusual names or handles with digits (
coolcat123@) can still be flagged. Log rejections so you can spot false positives. - A clean verdict isn't proof of a person. A bot with a real Gmail address passes this check. Pair it with a rate limit per IP, a form challenge, and resource caps until the user confirms their email.
- This doesn't confirm the mailbox exists. The lookup classifies the address. To check the mailbox itself, call
POST /v1/verify, which runs an SMTP check and returnsvalid,invalid,riskyorunknown. That takes longer and has its own budget (300 addresses a day and 3,000 a month per account on the Free plan), so most signup flows use it only for higher-value accounts. Catch-all domains come backrisky, nevervalid. - Rate and daily limits. 60 requests a minute per account and, on the Free plan, 2,000 lookups a day and 30,000 a month, cache hits included (Enterprise has custom limits). Over either, you get a
429. The fail-open code above handles that.
Next step
Sign in at the dashboard to create an API key, then wire the screenEmail function into your signup route. The full request and response schema, including every verdict.reason value, is in the API reference. If your fake signups are really about people restarting trials, protecting free trials picks up where this guide ends.
Questions people ask
- What is the fastest way to stop fake signups?
- Check the email address server-side before you create the account. Reject disposable domains and machine-generated local parts, and flag role or system addresses for review instead of blocking them. A single lookup with enrichment turned off returns in milliseconds.
- Will blocking disposable emails stop bots?
- It stops the cheapest kind of bot, the one that grabs a throwaway inbox for each account. Bots using real webmail addresses or custom domains need other layers too, such as rate limits per IP, a challenge on the form and usage caps until the email is confirmed.
- Should I block signups from Gmail and other free email providers?
- Not unless your product is strictly B2B and you're willing to lose some real buyers. Many legitimate users sign up with personal addresses. Block disposable and randomized addresses, and use free webmail as a routing signal rather than a reason to reject.