Skip to content

// crm

Via API

Attio email verification with pingutil

Attio fills up with people from email sync, imports and forms, and nothing tells you which addresses still work before you send. A webhook on record.created sends new people to a small service that verifies the address with pingutil and writes the status, reason and email category to custom attributes on the person.

Where it connects: Attio webhook subscribed to record.created, handled by a service that updates the person record via PATCH /v2/objects/people/records/{record_id}

What goes wrong without it

  • Attio pulled every address from our inbox history, and some of them are long dead.
  • Our lists mix founders' work emails with personal Gmail accounts, and we cannot filter on it.
  • We find out an address is wrong only after an outreach email bounces.

What you can do with Attio and pingutil

  • Verify new people

    Write `status` and `reason` to text attributes. List views and sequences can filter out `invalid`.

  • Filter by email type

    Write `category` (company, free, isp, disposable, educational, government) so lists separate business contacts from personal ones.

  • Flag low-trust addresses

    Store `verdict.reason` when it is `role_based` or `system_generated`, so shared inboxes and noreply addresses do not count as real contacts.

Set it up

  1. 1

    On the People object, create text attributes with slugs `email_status`, `email_reason` and `email_category`.

  2. 2

    Create an access token with record read-write scope and a webhook in workspace settings (or `POST /v2/webhooks`) subscribed to `record.created`; save the webhook secret.

  3. 3

    Deploy the service below with `ATTIO_TOKEN`, `ATTIO_WEBHOOK_SECRET`, `PEOPLE_OBJECT_ID` and `PINGUTIL_KEY`.

  4. 4

    The service checks `Attio-Signature`, answers immediately, then fetches the person, verifies the email and patches the attributes.

  5. 5

    Create a saved view that filters on email_status.

Attio record.created webhook receiver
// node >= 18, npm install express
import express from 'express';
import crypto from 'node:crypto';

const ATTIO = 'https://api.attio.com/v2/objects/people/records/';
const at = { authorization: 'Bearer ' + process.env.ATTIO_TOKEN, 'content-type': 'application/json' };
const pu = { authorization: 'Bearer ' + process.env.PINGUTIL_KEY, 'content-type': 'application/json' };

const app = express();
app.use(express.raw({ type: '*/*' }));

app.post('/attio', (req, res) => {
  const sig = crypto.createHmac('sha256', process.env.ATTIO_WEBHOOK_SECRET).update(req.body).digest('hex');
  if (sig !== req.headers['attio-signature']) return res.sendStatus(401);
  res.sendStatus(200); // Attio times out after 5 seconds
  const body = JSON.parse(req.body.toString());
  for (const e of body.events ?? [body]) {
    if (e.event_type === 'record.created' && e.id?.object_id === process.env.PEOPLE_OBJECT_ID) {
      handlePerson(e.id.record_id).catch((err) => console.error(err));
    }
  }
});

async function pingutil(path, body) {
  const r = await fetch('https://pingutil.com' + path, {
    method: 'POST', headers: pu, body: JSON.stringify(body), signal: AbortSignal.timeout(30_000),
  });
  return r.ok ? r.json() : null; // fail open on 429 or errors
}

async function handlePerson(recordId) {
  const rec = await fetch(ATTIO + recordId, { headers: at }).then((r) => r.json());
  const email = rec.data?.values?.email_addresses?.[0]?.email_address;
  if (!email) return;

  const [v, l] = await Promise.all([pingutil('/v1/verify', { email }), pingutil('/v1/lookup', { input: email, skip_enrichment: true })]);
  const values = {};
  if (v) Object.assign(values, { email_status: v.status, email_reason: v.reason });
  if (l) values.email_category = l.category;
  if (!Object.keys(values).length) return;

  await fetch(ATTIO + recordId, { method: 'PATCH', headers: at, body: JSON.stringify({ data: { values } }) });
}

app.listen(process.env.PORT ?? 3000);

What to do with each result

pingutil resultAction in Attio
`status: "valid"`Keep in outreach lists.
`status: "invalid"`Remove from outreach views; the mailbox does not exist or the domain has no mail server.
`status: "risky"` or `"unknown"`Keep the person, but send at low volume and re-check unknowns later.
`category: "free"` or `"isp"`Filter out of B2B pipelines or tag for review.
`verdict.low_trust` with `reason: "role_based"`Treat as a shared inbox, not a named contact.

Limits to plan for

  • Attio times out webhook deliveries after 5 seconds and retries failures up to 10 times over about 3 days, so the service answers before verifying.
  • Email sync can create many people at once; pingutil allows 60 requests a minute and 300 verified addresses a day (3,000 a month) per account, so verify the backlog in batches of 50 with `/v1/verify/batch` over several days. Those are Free plan limits; Enterprise has custom limits.
  • The snippet uses fast mode (`skip_enrichment: true`) for category only; drop it if you want `company.*` fields for a company attribute.

Attio documentation

Attio is a trademark of its owner. This integration uses Attio's documented extension points; it is not an official Attio app.

Common questions

Why fetch the person instead of reading the email from the webhook?
Attio webhook payloads carry ids, not attribute values, so the service reads the record through the REST API before verifying.
Does patching the person cause a loop?
No. The service listens to record.created only, and the patch is an update.

Stop bad addresses in Attio 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 Attio setup will receive.