Skip to content

For SaaS companies

Email verification for SaaS signups that stops fake accounts

Verify every address at signup with one API call or one script tag. Block disposable inboxes, catch typos before they cost you a user, and keep your sending domain healthy.

  • Typically under half a second
  • Node.js and Python SDKs
  • Free sandbox keys

The problem

Bad addresses get in at signup and cost you later

Every account starts with an email address. When that address is fake or mistyped, the damage shows up in activation, support and deliverability.

  • Fake and throwaway signups

    Disposable inboxes create accounts that never activate, skew your funnel metrics and drain free-trial resources.

  • Real users lost to typos

    A mistyped domain means the welcome email, password reset and onboarding sequence never arrive. The user just churns.

  • Bounces on your sending domain

    Transactional mail to dead addresses raises your bounce rate and puts password resets and receipts at risk for everyone.

The fix

Verify at every point an address enters your product

Use one layer or all of them. They share the same engine, the same results and one balance of credits.

  1. Check the address at the form

    Add RocketShield to your signup page with one script tag. Addresses are checked as they are typed, with the blocking rules and message you choose in the dashboard.

  2. Verify again on the server

    Call the API from your signup handler before you create the account. The result tells you whether to accept, suggest a correction or reject.

  3. Handle the rest asynchronously

    Verify imported users and your existing database with bulk jobs, and let signed webhooks tell your backend when a job completes or credits run low.

  4. Keep your CRM in sync

    Connect HubSpot or Salesforce so every new contact is verified and the result is written into contact fields your sales and lifecycle teams can use.

Signup check

One call decides accept, correct or reject

Accept deliverable addresses, offer the did_you_mean suggestion for typos, reject disposable and undeliverable ones, and let risky or unknown users through with a flag.

  • status: deliverable, undeliverable, risky or unknown
  • sub_status explains why, for example possible_typo or disposable
  • did_you_mean suggests the corrected address
  • The Node.js SDK returns camelCase fields and real booleans
import RocketVerifier from '@rocketverifier/sdk';

const rv = new RocketVerifier(process.env.RV_API_KEY);

export async function checkSignupEmail(email) {
  const result = await rv.verify(email);

  if (result.status === 'deliverable') return { ok: true };

  // "jane@gmial.com" → suggest "jane@gmail.com"
  if (result.didYouMean) return { ok: false, suggestion: result.didYouMean };

  // throwaway inboxes
  if (result.domain.disposable || result.subStatus === 'disposable') {
    return { ok: false, error: 'Please use a permanent email address.' };
  }

  if (result.status === 'undeliverable') {
    return { ok: false, error: 'This address cannot receive email.' };
  }

  // risky or unknown: let them in, flag for review
  return { ok: true, review: result.subStatus };
}
import os
from rocketverifier import RocketVerifier

rv = RocketVerifier(os.environ["RV_API_KEY"])

def check_signup_email(email):
    result = rv.verify(email)

    if result.status == "deliverable":
        return {"ok": True}
    if result.did_you_mean:
        return {"ok": False, "suggestion": result.did_you_mean}
    if result.domain.disposable or result.sub_status == "disposable":
        return {"ok": False, "error": "Please use a permanent email address."}
    if result.status == "undeliverable":
        return {"ok": False, "error": "This address cannot receive email."}

    # risky or unknown: let them in, flag for review
    return {"ok": True, "review": result.sub_status}
$ curl -X POST https://api.rocketverifier.com/v1/verify \
  -H "Authorization: Bearer $RV_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "trial4free@mailinator.com"}'

{
  "status": "undeliverable",
  "sub_status": "disposable",
  "domain": { "name": "mailinator.com", "disposable": "yes", ... },
  "did_you_mean": null
}

Built for production

Everything you need to ship it safely

  • Sandbox keys

    Test keys (rv_test_...) return deterministic results for @sandbox.rocketverifier.com addresses without spending credits.

  • Signed webhooks

    job.completed, credits.low, credits.depleted and email.verified events, signed with X-RocketVerifier-Signature.

  • Key controls

    Per-key monthly spend caps, expiry dates and IP allowlists keep a leaked or runaway key contained.

  • Versioned responses

    Pin response behaviour with the RocketVerifier-Version header so upgrades never surprise your signup flow.

FAQ

Signup verification, answered

What product and engineering teams ask before they ship.

Should I verify on the client, the server or both?

Both work well together. RocketShield gives instant feedback in the form so real users can fix mistakes before they submit, and the API adds a did_you_mean suggestion you can show for typos. A server-side API call in your signup handler is the final check that cannot be bypassed.

Will verification slow down my signup flow?

No. Verification typically answers in under half a second, or 1 to 3 seconds when a live SMTP check is needed. Most teams verify while the rest of the signup request runs, and treat a timeout as unknown so a slow mail server never blocks a real user.

How do I block disposable email addresses?

Check result.domain.disposable (or a sub_status of disposable) in the API response, or switch on the block-disposable rule for RocketShield in the dashboard. The disposable domain database is updated continuously.

What should I do with risky or unknown results at signup?

Usually let the user in and flag the account. Unknown means the mail server would not give a clear answer, and unknown results are never charged. Risky covers role addresses and catch-all domains; the catch_all_verdict field tells you how safe a catch-all address is to mail.

Can I test the integration without spending credits?

Yes. Create a sandbox key (rv_test_...) and verify addresses at @sandbox.rocketverifier.com to get deterministic responses for every status, at no cost.

Does RocketVerifier sync results to HubSpot or Salesforce?

Yes. The HubSpot integration verifies contacts, writes the result into contact properties and can verify new contacts the moment they are created. Salesforce writes results into custom fields on Leads and Contacts.

Ship signup verification this week

Start with sandbox keys, go live with the same code. Unknown results are always free, and credits never expire.

100 free credits · No card required · Credits never expire