Skip to content

// forms and surveys

Via API

Tally 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. 1

    Create a pingutil key and set PINGUTIL_KEY on your server.

  2. 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. 3

    Deploy the Express handler below. It verifies the signature on the raw body and responds before doing any slow work.

  4. 4

    Submit a test response and check that a 200 appears in the Tally webhook event log.

  5. 5

    Replace the forward() target with your CRM, email platform or database.

Express receiver for Tally webhooks
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 resultAction in Tally
verdict.is_spam: trueDrop 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 setStore 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.