// forms and surveys
Via APITally email verification with pingutil
Tally forms are often public links shared on social, so they collect a steady trickle of disposable and mistyped addresses. A webhook receiver checks the Tally signature, replies inside Tally's 10 second window and then verifies the INPUT_EMAIL answer with pingutil, forwarding only addresses that can receive mail. Tally sends the webhook after the response is saved, so this is filtering, not blocking.
Where it connects: Tally webhooks (FORM_RESPONSE event, Tally-Signature header)
What goes wrong without it
- We launched a waitlist on Tally and a third of the sign-ups look like keyboard mashing.
- Our Tally webhook kept retrying because the handler took too long to answer.
- Beta invites go out to addresses nobody reads, and our sender reputation pays for it.
What you can do with Tally and pingutil
Filter waitlist and beta sign-ups
Forward valid addresses to your email platform or database and keep invalid and disposable ones in a separate table you can inspect, instead of inviting them.
Catch machine-generated addresses fast
Call /v1/lookup with skip_enrichment first and drop anything with verdict.is_spam (disposable domains and randomized local parts) without spending a mailbox check.
Score inbound leads by company
For valid company addresses, a full /v1/lookup returns the company profile (industry, size estimate, headquarters) to attach to the lead.
Set it up
- 1
Create a pingutil key and set PINGUTIL_KEY on your server.
- 2
In Tally, open the form, go to Integrations, choose Webhooks, enter your endpoint URL and enable a signing secret. Store it as TALLY_SIGNING_SECRET.
- 3
Deploy the Express handler below. It verifies the signature on the raw body and responds before doing any slow work.
- 4
Submit a test response and check that a 200 appears in the Tally webhook event log.
- 5
Replace the forward() target with your CRM, email platform or database.
import express from 'express';
import { createHmac, timingSafeEqual } from 'node:crypto';
const app = express();
type TallyField = { key: string; label: string; type: string; value: unknown };
async function pingutil(path: string, body: object, timeoutMs: number) {
try {
const res = await fetch('https://pingutil.com' + path, {
method: 'POST',
headers: { authorization: 'Bearer ' + process.env.PINGUTIL_KEY, 'content-type': 'application/json' },
body: JSON.stringify(body),
signal: AbortSignal.timeout(timeoutMs),
});
return res.ok ? await res.json() : null;
} catch {
return null; // fail open
}
}
async function screen(responseId: string, email: string) {
// Fast check first: disposable domains and random-looking addresses.
const lookup = await pingutil('/v1/lookup', { input: email, skip_enrichment: true }, 3000);
if (lookup?.verdict?.is_spam) return console.log('tally spam', responseId, lookup.verdict.reason);
const check = await pingutil('/v1/verify', { email }, 20000);
if (check?.status === 'invalid') return console.log('tally invalid', responseId, check.reason);
await forward({ responseId, email, email_status: check?.status ?? 'unchecked', did_you_mean: check?.did_you_mean ?? null });
}
async function forward(lead: object) {
await fetch(process.env.CRM_WEBHOOK_URL!, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify(lead),
});
}
app.post('/webhooks/tally', express.raw({ type: 'application/json' }), (req, res) => {
const raw = req.body as Buffer;
const expected = createHmac('sha256', process.env.TALLY_SIGNING_SECRET!).update(raw).digest('base64');
const got = req.get('tally-signature') ?? '';
if (got.length !== expected.length || !timingSafeEqual(Buffer.from(got), Buffer.from(expected))) {
return res.sendStatus(401);
}
res.sendStatus(200); // reply inside Tally's 10 second window, then do the slow part
const { data } = JSON.parse(raw.toString('utf8'));
const field = (data.fields as TallyField[]).find((f) => f.type === 'INPUT_EMAIL');
if (typeof field?.value === 'string' && field.value) {
screen(data.responseId, field.value).catch((err) => console.error('tally screen failed', err));
}
});
app.listen(3000);What to do with each result
| pingutil result | Action in Tally |
|---|---|
| verdict.is_spam: true | Drop the response from your list; no mailbox check needed. |
| status: "valid" | Forward to your CRM or email platform. |
| status: "invalid" | Keep it out of every send; log the responseId for review in Tally. |
| status: "risky" (accept_all) | Forward with the status so you can send to it last or after a confirmation step. |
| did_you_mean is set | Store the suggestion and use it if the first email bounces. |
Limits to plan for
- Tally gives your endpoint 10 seconds to return a 2XX and then retries up to five times over a day. Reply first and verify afterwards, or you will get duplicate deliveries.
- There is no Tally hook that can reject a response before it is saved, so respondents always see the thank-you page.
- Privacy-relay addresses (Apple Hide My Email, Firefox Relay) can be flagged as randomized by the fast check. Review those instead of dropping them if your audience uses them.
Tally documentation
Tally is a trademark of its owner. This integration uses Tally's documented extension points; it is not an official Tally app.
Common questions
- Which Tally field type holds the email?
- Email questions arrive in data.fields with type INPUT_EMAIL and the address as a plain string in value.
- Why verify the signature on the raw body?
- Tally signs the payload with HMAC SHA-256 and sends the base64 result in Tally-Signature. Hashing the exact bytes you received avoids mismatches caused by re-serializing JSON.
Stop bad addresses in Tally today
Sign in with your email, create an API key and paste it into the step above. Test on a few real addresses first: the live demo shows exactly what your Tally setup will receive.