# Verify emails in Make with Spaw

Call the Spaw API from Make's HTTP module in any scenario today and route on the verdict. Covers the Spaw app for Make, which is built and awaiting review.

Updated: 2026-09-03

Make (formerly Integromat) scenarios are a natural place for a verification step, because a router can send each address down a different branch depending on the verdict. Spaw has no special requirements: the API speaks JSON over HTTPS with a bearer token, which is exactly what Make's HTTP module sends. A dedicated Spaw app for Make is built and waiting for Make's review; until it is available, the HTTP module gives you every field the app will.

## What works today: the HTTP module

1. Create a secret API key on the API keys page of your Spaw dashboard. Keep it out of scenario names and notes; it starts with `sk_live_`.
2. In your scenario, add the HTTP module and pick the action that makes a request (it is the one that lets you set the method, headers and body by hand).
3. Set the URL to `https://spaw.co/api/v1/email` and the method to POST.
4. Add two headers: `Authorization` with the value `Bearer sk_live_…`, and `Content-Type` with the value `application/json`.
5. Set the body type to raw, the content type to JSON, and the request content to the JSON below, mapping the address from the module before it.
6. Turn on response parsing so the answer's fields become mappable in the modules that follow.

```json
{
  "email": "{{1.email}}"
}
```

Run the scenario once with `deliverable@spaw.test` as the address. It answers a canonical deliverable result, costs no credits and is never logged, so you can wire the whole flow before spending anything.

The parsed response carries `data` with the 27 fields of a [single-address lookup](/docs/api/verify-email) and `meta` with `credits_used`, `credits_remaining` and `cache_hit`. For a scenario that processes a list, use an array aggregator to collect up to 50 addresses, send them as `{ "emails": [...] }` to `https://spaw.co/api/v1/email/batch`, and iterate over `data.results`. The [batch endpoint](/docs/api/verify-email-batch) answers in input order and counts as one request against the rate limit.

To check only a domain, for example before enriching a company record, call `GET https://spaw.co/api/v1/email/domain/acme.com` with the same header. The [domain endpoint](/docs/api/domain-intelligence) answers whether the domain receives mail, who runs its mail, its SPF and DMARC status and its registration age.

## The Spaw app for Make

The app packages the same calls as modules with a saved connection, so nobody has to paste headers:

- A connection named Spaw API key that stores the secret key and verifies it against your account.
- Modules: Verify an Email, Verify Emails (up to 50), Get Domain Intelligence, and Add to Suppression List.
- Errors mapped to Make's own types: a rejected key stops the scenario with an authentication error, a rate limit raises a rate-limit error Make can retry, and everything else reports the API's message.

It is not in Make's app catalogue yet. This page will link the app when Make has finished its review. Scenarios built on the HTTP module keep working unchanged either way.

## What to do with the verdict

Put a router after the verification module with one filter per outcome. Route `deliverable` answers straight on. Send `risky` answers through a second filter on `reason`: a `catch_all` domain or a `role` inbox is usually worth keeping with a note, a `disposable` domain usually is not. Stop `undeliverable` answers, or write `did_you_mean` back to the source when it is filled, since a corrected typo is a recovered lead rather than a lost one. If you would rather compare a single number, `risk_score` is 0 to 100 and its weights are documented in the [risk score guide](/guides/how-spaw-computes-the-risk-score).

## Cost

Every verified address that answers deliverable or risky spends 1 credit; undeliverable answers, invalid input and repeats within seven days are free. Make counts its own operations separately. The API accepts 5 requests per second per key, so a scenario that bursts through a large list should use the batch endpoint or a short sleep between iterations.

Reference: https://spaw.co/integrations/make