// guide
How to stop repeat free-trial abuse without hurting real users
For saaS founders and growth engineers running a self-serve free trial · Updated · 6 min read
The same people keep starting new trials with new email addresses, and every one of them costs me real money.
To stop repeat free-trial abuse, make a new identity cost something at the moment your trial starts costing you. Screen each trial email with pingutil (reject disposable domains and machine-generated addresses), dedupe on a normalized form of the address so jane+2@gmail.com doesn't get a second trial, count recent trials per company domain, and hold back the expensive parts of the trial until the user confirms their email or adds a card.
Each of those steps is cheap to build. Together they turn "make a new account" from a five-second job into real work, which is usually enough.
What this problem costs you
Trial abuse is a pricing problem dressed up as a security one. Write down what one trial costs before you decide how hard to fight it:
- Direct spend. If a trial includes LLM tokens, GPU time, SMS, outbound email or storage, a repeat trialer is a recurring cost with no revenue behind it. If they've scripted it, the cost scales with their script, not your growth.
- Lost revenue. Someone on their sixth trial is, by definition, a user who would otherwise pay or leave. Either outcome is better for you than an endless trial.
- Polluted metrics. Trial-to-paid conversion drops when one person counts as six trials that never converted. You can end up changing pricing or onboarding to fix a problem that's really abuse.
- Reputation. Products that send email or host content for users get their infrastructure used for spam when trials are free to restart.
If a trial costs you close to nothing, light screening is enough. If each one costs real money, use every step below. The blog post on free-trial abuse has a longer discussion of the friction trade-offs.
How repeat trialers get a new identity
| Trick | Example | Countered by |
|---|---|---|
| Throwaway inbox | x@ a disposable domain |
verdict.is_spam (disposable_domain) |
| Generated webmail | qz8kx2mv@gmail.com |
verdict.is_spam (randomized_local_part) |
| Plus tag | jane+trial3@gmail.com |
Your normalization step |
| Gmail dots | j.a.n.e@gmail.com |
Your normalization step |
| Aliases on their own domain | jane1@, jane2@janedesign.io |
Per-domain trial count |
pingutil handles the first two. The next two are string operations you do yourself before the database lookup. The last uses pingutil's domain and category fields to tell you when counting per domain is safe.
How pingutil solves it
1. Get a key and try your own abuse cases
Create an API key at the dashboard. Then take the addresses from your last few abused trials and run them through the live demo. You'll see quickly which of your abusers the verdict would have caught and which need the other steps.
2. Screen the email when the trial starts
Call POST https://pingutil.com/v1/lookup with skip_enrichment: true. You only need category, domain and verdict for this, and skipping enrichment keeps it to milliseconds. Reject on verdict.is_spam.
3. Normalize and dedupe
Lowercase the address, strip everything after + in the local part, and for gmail.com and googlemail.com remove dots. Store that normalized key on the trial record with a unique index. If it already exists, don't start a second trial: offer the paid plan or a sign-in link instead. Email normalization for Gmail dots and plus tags covers which providers this is safe for.
4. Count trials per company domain
pingutil returns domain as the registrable domain (mail.janedesign.io becomes janedesign.io), so subdomain tricks collapse into one key. When category is company, count trials on that domain in the last 30 days. Several from one domain is a soft signal: maybe a team, maybe one person with aliases. Don't reject on it. Shorten the trial, or route it to a person.
Only do this for company. For free, isp and educational the domain is shared by huge numbers of unrelated people.
5. Gate the expensive parts
Give every trial the cheap features immediately. Release the costly ones (API credits, sending, large exports) after the email is confirmed. For the highest-cost resources, ask for a card. A screen at signup raises the price of an identity; this step caps what one identity can take.
Decision table: response field to action
| Field and value | Recommended action |
|---|---|
verdict.is_spam: true |
Don't start a trial. Ask for a permanent address |
verdict.reason: "system_generated" |
Don't start a trial |
verdict.low_trust: true (role_based, sales_outreach) |
Start a trial with tighter caps until the email is confirmed |
| Normalized email already has a trial | Don't start a second trial. Offer upgrade or sign-in |
category: "company" and 3 or more trials on domain in 30 days |
Start a short trial, flag for review |
category: "free" or "isp", verdict clean |
Normal trial. Don't count per domain |
category: "educational" |
Normal trial, or route to an education offer if you have one |
Lookup failed (timeout, 429, 5xx) |
Start a normal trial, mark as unscreened, re-check later |
The threshold of three is a starting point, not a rule. Pick one from your own data: look at how many trials per domain your real paying teams start.
Complete example: trial start in Python
A Flask route using requests and SQLite. Swap the database for yours; the logic stays the same.
# trial.py (Python 3.9+, pip install flask requests)
import os
import sqlite3
from datetime import datetime, timedelta, timezone
import requests
from flask import Flask, jsonify, request
app = Flask(__name__)
KEY = os.environ["PINGUTIL_KEY"] # pk_live_...
db = sqlite3.connect("trials.db", check_same_thread=False)
db.execute(
"""CREATE TABLE IF NOT EXISTS trials (
email_key TEXT PRIMARY KEY,
email TEXT NOT NULL,
domain TEXT,
category TEXT,
status TEXT NOT NULL,
created_at TEXT NOT NULL)"""
)
GMAIL = {"gmail.com", "googlemail.com"}
def normalize(email: str) -> str:
local, _, host = email.strip().lower().rpartition("@")
local = local.split("+", 1)[0]
if host in GMAIL:
local = local.replace(".", "")
host = "gmail.com"
return f"{local}@{host}"
def screen(email: str):
try:
r = requests.post(
"https://pingutil.com/v1/lookup",
json={"input": email, "skip_enrichment": True},
headers={"Authorization": f"Bearer {KEY}"},
timeout=3,
)
except requests.RequestException:
return None
if r.status_code == 400:
return {"category": "unknown", "domain": None, "verdict": {"is_spam": True}}
return r.json() if r.ok else None
def recent_trials_on(domain: str) -> int:
since = (datetime.now(timezone.utc) - timedelta(days=30)).isoformat()
row = db.execute(
"SELECT COUNT(*) FROM trials WHERE domain = ? AND category = 'company' AND created_at > ?",
(domain, since),
).fetchone()
return row[0]
@app.post("/trials")
def start_trial():
email = str(request.json.get("email", "")).strip()
if "@" not in email:
return jsonify(error="Enter a valid email address."), 400
key = normalize(email)
if db.execute("SELECT 1 FROM trials WHERE email_key = ?", (key,)).fetchone():
return jsonify(error="This address already had a trial. Sign in or pick a plan."), 409
data = screen(email)
status = "standard"
if data is None:
status = "unscreened"
else:
verdict = data["verdict"]
if verdict.get("is_spam") or verdict.get("reason") == "system_generated":
return jsonify(error="Please use a permanent email address."), 422
if verdict.get("low_trust"):
status = "limited"
if data["category"] == "company" and recent_trials_on(data["domain"]) >= 3:
status = "review"
db.execute(
"INSERT INTO trials VALUES (?, ?, ?, ?, ?, ?)",
(
key,
email,
data and data.get("domain"),
data and data.get("category"),
status,
datetime.now(timezone.utc).isoformat(),
),
)
db.commit()
return jsonify(trial=status), 201
status drives what the trial gets. standard gets everything after email confirmation, limited gets lower caps, review gets a short trial and a ping to whoever owns abuse, and unscreened gets a background re-check.
Edge cases and limits
- Determined abusers get through. Someone willing to register fresh Gmail accounts by hand passes the email check every time. That's why step 5 exists. Email signals raise the cost; caps and cards bound the loss.
- Normalization rules differ by provider. Gmail ignores dots; most other providers don't. Plus-addressing works at many providers but not all. Stripping too aggressively can merge two real people, so apply the dot rule only to Gmail.
- Teams look like abuse. Five trials from one company domain is often five colleagues. Flag, don't reject, and consider a team trial so they don't need five. Detecting teammates from the same company covers that pattern.
- New disposable domains slip past. The disposable list is about 9,900 domains, re-synced weekly from a community project. A brand-new throwaway domain can be clean for a few days.
- Privacy relays. Apple Hide My Email and similar relays can be flagged as randomized even though they are real forwarding addresses. Give them a
limitedtrial instead of a rejection if those users matter to you. - Limits. 60 requests a minute, 2,000 lookups a day and 30,000 a month per account on the Free plan. The example treats a failed lookup as
unscreenedrather than blocking the trial.
Next step
Create an API key at the dashboard and add the screen call to your trial-start route. Field definitions are in the API reference. If fake accounts are hitting you before they ever reach a trial, start with stopping fake signups; for the wider fraud picture, see the free-trial abuse use case.
Questions people ask
- How do people abuse free trials?
- Mostly by creating a new identity each time a trial ends: a throwaway inbox, a plus-tagged or dotted variant of the same Gmail address, or a fresh alias on their own domain. The product sees a new user each time and hands out a new trial.
- Can an email check alone stop free-trial abuse?
- No. It removes the cheapest identities, which is where most abuse starts, but a determined abuser can register real webmail accounts. Combine email screening with a normalized-identity check and release expensive features only after stronger proof such as a confirmed email or a card.
- Should I count trials per company domain?
- For company domains, yes, as a soft signal. Several trials from one custom domain in a short window is either a team evaluating you or one person cycling aliases. Free webmail domains are shared by millions of people, so never count trials per gmail.com.