Fake leads from Facebook lead ads and Google lead forms: filter them before the CRM
· Updated · 7 min read · Business email
Fake leads from Facebook lead ads and Google Ads lead forms come from the same design choice: the form is built to be submitted in seconds without leaving the app, so it captures accidental taps, curiosity clicks and some automated junk along with real buyers. You can't make the platform stop sending them, but you can catch most of them in a webhook between the ad platform and your CRM: check the email, mark the lead, and only hand real ones to sales.
This post covers why the junk happens, what a filter can and can't detect, and a working Node.js webhook for both platforms.
Why instant forms produce more junk than landing pages
A landing-page form has friction built in. The person clicked through, waited for a page to load, and typed their details. Instant forms remove most of that, which is why they convert well, and also why lead quality drops.
The common sources of bad leads:
- Accidental or low-intent submissions. The form opens inside the feed. Someone taps through to see what's offered, and the submit button is one tap away. They never meant to talk to sales.
- Pre-filled or stale contact details. These forms are built to minimise typing. Depending on the platform and how you configure the form, the contact fields may arrive filled from the person's account, and the address on an old social account is often one they no longer read.
- Typed-in junk. People who want the offer (a download, a quote, a discount) but not the follow-up type
asdf@asdf.comor a throwaway inbox. - Bots and click farms. Less common than the first three, but they show up in bursts, often with machine-generated addresses or the same domain repeated.
- Competitors and tyre-kickers. Real addresses, real people, no buying intent. No email check will catch these, which is worth saying up front.
The platforms offer settings that trade volume for quality. Google, for example, documents OTP verification for lead forms, and Meta's form builder lets you add custom questions that make a casual tap less likely. Use them where your volume allows. A filter after the form is still needed because no form setting can tell you whether jane@acme-corp.com actually exists.
What an email check can tell you about a lead
| Signal | What it catches | API field |
|---|---|---|
| Mailbox doesn't exist | Typos, made-up addresses, abandoned accounts | status: "invalid" from /v1/verify |
| Domain has no mail server | asdf@asdf.com-style junk |
reason: "no_domain" or "no_mx" |
| Disposable inbox | People avoiding follow-up | verdict.is_spam, category: "disposable" |
| Machine-generated local part | Bots | verdict.reason: "randomized_local_part" |
| Role address | info@, sales@: real but not a person |
verdict.low_trust, reason: "role_based" |
| Free webmail vs company domain | Personal vs business intent (B2B only) | category: "free" or "company" |
| Catch-all domain | Can't confirm the mailbox | status: "risky", reason: "accept_all" |
For a B2B offer, the category is often as useful as deliverability. A lead at a company domain with a known industry and size goes to sales; a gmail.com lead might go to a nurture sequence instead. That's a routing choice, not a rejection: plenty of founders and small-business owners use webmail. Qualifying B2B leads by email goes into that scoring.
What the platforms send to your webhook
Both platforms can push leads to an HTTPS endpoint you control. The payloads differ.
Google Ads lead forms POST JSON to the webhook URL you set on the form. Per Google's webhook implementation guide, the body includes lead_id, form_id, campaign_id, a user_column_data array of { column_id, string_value } items (the email is the item with column_id: "EMAIL"), an optional is_test flag, and a google_key you configure on the form. Google recommends checking that google_key matches before processing.
Meta lead ads send a webhook notification on the Page's leadgen field. The notification carries a leadgen_id, not the lead data. Your server then fetches the lead from the Graph API, which returns a field_data array of { name, values } items, as described in Meta's lead retrieval guide. Webhook requests are signed with your app secret in the X-Hub-Signature-256 header.
The webhook
Node 18+, Express, built-in fetch. One route per platform, one shared function that checks the email and decides where the lead goes. pushToCrm and pushToReview are stubs for your CRM call.
// lead-webhook.mjs
import express from 'express';
import crypto from 'node:crypto';
const PINGUTIL_KEY = process.env.PINGUTIL_KEY;
const GOOGLE_LEAD_KEY = process.env.GOOGLE_LEAD_KEY; // the key set on the Google lead form
const META_APP_SECRET = process.env.META_APP_SECRET;
const META_VERIFY_TOKEN = process.env.META_VERIFY_TOKEN; // any string you choose
const META_PAGE_TOKEN = process.env.META_PAGE_TOKEN; // page access token with leads permission
const GRAPH = 'https://graph.facebook.com/v21.0'; // use the version your app targets
const app = express();
// Keep the raw body so the Meta signature can be checked.
app.use(express.json({ limit: '64kb', verify: (req, _res, buf) => { req.rawBody = buf; } }));
async function pingutil(path, body) {
const res = await fetch(`https://pingutil.com${path}`, {
method: 'POST',
headers: { authorization: `Bearer ${PINGUTIL_KEY}`, 'content-type': 'application/json' },
body: JSON.stringify(body),
signal: AbortSignal.timeout(30_000),
});
if (!res.ok) throw new Error(`pingutil ${path} ${res.status}`);
return res.json();
}
async function triageLead(lead) {
if (!lead.email) return pushToReview(lead, 'no_email');
let verify, lookup;
try {
[verify, lookup] = await Promise.all([
pingutil('/v1/verify', { email: lead.email }),
pingutil('/v1/lookup', { input: lead.email, skip_enrichment: true }),
]);
} catch (err) {
// Never drop a lead because a check failed. Send it on, flagged.
return pushToCrm({ ...lead, email_check: 'unavailable' });
}
const tagged = {
...lead,
email_status: verify.status,
email_reason: verify.reason,
email_category: lookup.category,
did_you_mean: verify.did_you_mean,
};
if (verify.status === 'invalid' || lookup.verdict.is_spam) {
return pushToReview(tagged, verify.status === 'invalid' ? verify.reason : lookup.verdict.reason);
}
if (lookup.category === 'company' && verify.status === 'valid') {
return pushToCrm({ ...tagged, lead_tier: 'sales' });
}
// risky (catch-all, role), unknown, free webmail: real enough to keep, not sales-ready yet.
return pushToCrm({ ...tagged, lead_tier: 'nurture' });
}
// ---- Google Ads lead form webhook
app.post('/webhooks/google-lead', async (req, res) => {
const body = req.body ?? {};
if (body.google_key !== GOOGLE_LEAD_KEY) return res.sendStatus(403);
res.sendStatus(200); // acknowledge fast, work after
if (body.is_test) return;
const field = (id) => body.user_column_data?.find((c) => c.column_id === id)?.string_value ?? null;
await triageLead({
source: 'google_ads',
external_id: body.lead_id,
campaign_id: body.campaign_id,
email: field('EMAIL'),
name: field('FULL_NAME'),
phone: field('PHONE_NUMBER'),
}).catch((e) => console.error('google lead', body.lead_id, e));
});
// ---- Meta lead ads: subscription handshake
app.get('/webhooks/meta-lead', (req, res) => {
if (req.query['hub.mode'] === 'subscribe' && req.query['hub.verify_token'] === META_VERIFY_TOKEN) {
return res.send(req.query['hub.challenge']);
}
res.sendStatus(403);
});
// ---- Meta lead ads: notifications
app.post('/webhooks/meta-lead', async (req, res) => {
const sig = req.get('x-hub-signature-256') ?? '';
const expected = 'sha256=' + crypto.createHmac('sha256', META_APP_SECRET).update(req.rawBody ?? '').digest('hex');
const ok = sig.length === expected.length && crypto.timingSafeEqual(Buffer.from(sig), Buffer.from(expected));
if (!ok) return res.sendStatus(403);
res.sendStatus(200);
for (const entry of req.body.entry ?? []) {
for (const change of entry.changes ?? []) {
if (change.field !== 'leadgen') continue;
const id = change.value.leadgen_id;
try {
const r = await fetch(`${GRAPH}/${id}?access_token=${encodeURIComponent(META_PAGE_TOKEN)}`);
const lead = await r.json();
const field = (name) => lead.field_data?.find((f) => f.name === name)?.values?.[0] ?? null;
await triageLead({
source: 'meta_lead_ads',
external_id: id,
campaign_id: change.value.ad_id,
email: field('email'),
name: field('full_name'),
phone: field('phone_number'),
});
} catch (e) {
console.error('meta lead', id, e);
}
}
}
});
// Stubs: replace with your CRM and review-queue calls.
async function pushToCrm(lead) { console.log('CRM', lead.lead_tier ?? '-', lead.email); }
async function pushToReview(lead, reason) { console.log('REVIEW', reason, lead.email); }
app.listen(3000);
A few notes on why it's shaped like this.
- Acknowledge first, check second. A mailbox check can take several seconds when a mail server is slow. Both platforms expect a quick response, so the handler returns 200 and does the work afterwards. In production, push the lead onto a queue instead of processing in the same process, so a restart doesn't lose it.
- Field names are yours. The Meta
field_datanames (email,full_name,phone_number) are the standard question IDs; custom questions get their own names. Log one real payload from each form before trusting the mapping. - Rejected leads go to review, not the bin. A lead with a dead email and a working phone number is still a lead. And the rejection count per campaign is the number your ads team actually needs.
Feed the results back to the ad platform
Filtering protects your CRM, but the ad platform keeps optimising for whoever submits the form. If you report which leads turned out to be real (both platforms support importing offline conversions or lead quality signals), bidding can shift towards the people who look like your good leads. The exact mechanism differs by platform and changes often, so follow the platform's current docs rather than a blog post for that part.
Even without conversion imports, tag each lead with campaign_id and email_status. A weekly query of invalid and disposable rates per campaign tells you which audiences and creatives attract junk.
Limits worth knowing before you ship
- Catch-all domains can't be confirmed. Many company domains accept mail for any address. Those come back
riskywithreason: "accept_all", which is why the code routes them to nurture instead of rejecting. More in catch-all email domains. - Some servers won't answer. Those come back
unknown. Don't reject them. - Budgets. Every verified address counts toward your account's daily verification budget of 300 addresses (API and dashboard CSV combined). If you run high-volume lead campaigns, check that the volume fits before you switch the webhook on, and keep the fail-open branch so a
429never drops a lead. - Intent is invisible. A competitor with a real work address passes every check here.
If your leads come from website forms rather than ad platforms, filtering fake form leads with a webhook covers Tally and Typeform, and the guide to verifying leads before the CRM covers the routing rules in more depth. The lead qualification use case shows how teams combine the category and company profile into a score.
Questions people ask
- Why are my Facebook lead ads getting fake leads?
- Instant forms are designed to be submitted in a couple of taps without leaving the app, so they collect accidental submissions, low-intent curiosity and some automated junk alongside real interest. The fix is to check each lead's contact details before it reaches sales, plus form settings that add friction.
- Can I verify the email on a Google Ads lead form?
- Google Ads lets you deliver leads to a webhook URL, which receives the submitted fields as JSON. Your webhook can check the email with a verification API before passing the lead on. Google also documents OTP verification for some lead form fields.
- Should I delete leads that fail an email check?
- Keep them in a separate review list instead. Some will have a phone number that works, and the count of rejected leads per campaign is one of the best signals you have for which ads attract junk.