# Catch-all domains

Source: https://docs.rocketverifier.com/catch-all

> A catch-all domain accepts mail for every address, so a plain SMTP check cannot tell a real mailbox from a made-up one. RocketVerifier scores each address on the domain from 0 to 100 and returns a catch_all_verdict of send_safe, send_with_caution or avoid. Catch-all results cost 1 credit and report status risky under result version 2026-11-01.

A catch-all (or accept-all) domain tells the mail server to accept every recipient, real or not. Any verifier that stops at the SMTP handshake can only say "this domain accepts everything". RocketVerifier goes further and decides, address by address, which ones are worth sending to.

## How a catch-all domain is detected

During the SMTP conversation, RocketVerifier also asks the server about a random address on the same domain, a 14 character string that no real mailbox uses. If the server accepts it, the domain is catch-all. The probe result is cached per domain for 7 days, so later addresses on the domain skip it.

Two outcomes are worth knowing:

- **Accepted, probe inconclusive.** When the server accepts the address but blocks or times out the random-address probe, an accept-all domain cannot be ruled out. The result is `unknown`, and free.
- **Rejected on a catch-all domain.** When a domain that accepts nearly everything explicitly rejects this address, the result is `undeliverable` with `mailbox_not_found`.

## How the verdict is reached

The Catch-All Resolution Engine turns the signals below into a 0 to 100 resolution score for the specific address.

1. **Local part plausibility.** Does the part before the `@` look like a real person's name (`maya.patel`, `mpatel`) or a generated string (`xk29fj2`)? This is the starting point.
2. **The domain's naming pattern.** RocketVerifier learns which naming convention a domain uses (`first.last`, first initial plus last name, and so on) from mailboxes confirmed while the domain still answered per mailbox. An address that matches the convention scores higher; one that breaks it scores lower. The weight grows with how many confirmed mailboxes back the pattern and how consistently the domain uses it.
3. **Mail provider.** A catch-all on a well-run mail platform gets a small boost over one on an unknown, self-hosted server.
4. **Bounce feedback.** Hard bounces from connected sending platforms show how often addresses on the domain, and of each naming shape, bounce after being accepted.
5. **Verification history.** A definitive answer for this exact address, from a check made while the domain still answered per mailbox, overrides the estimate: a confirmed mailbox scores at least 88, a confirmed rejection or a later hard bounce at most 10.

The pattern store holds counts of naming shapes per domain, never addresses, and keeps them for 180 days. Bounce feedback and verification history are stored as domain aggregates and keyed hashes, and only accounts that share in the data network use them. You can turn that off under **Settings → Privacy**.

The score maps to a verdict:

| catch_all_verdict | Meaning |
| --- | --- |
| `send_safe` | Resolution score 65 or higher: strong signals this mailbox is real and active. |
| `send_with_caution` | Resolution score 35 to 64, or too little evidence to decide. Send to engaged segments or warm the address first. |
| `avoid` | Resolution score below 35: signals point to a mailbox that does not exist. |

## Read the catch-all fields

A catch-all result carries the verdict in three places, so every integration finds it:

Catch-all result (excerpt):

```json
{
  "email": "maya.patel@lakeside-dental.com",
  "status": "risky",
  "sub_status": "catch_all",
  "catch_all_verdict": "send_safe",
  "catch_all": {
    "verdict": "send_safe",
    "score": 82,
    "method": "pattern",
    "reasons": [
      "Local part looks like a real name (e.g. first.last)",
      "Matches this domain's known naming pattern (first.last, seen in 92% of 25 verified mailboxes)"
    ]
  },
  "domain": { "name": "lakeside-dental.com", "acceptAll": "yes", "disposable": "no", "free": "no" }
}
```

- `catch_all_verdict` is the recommendation. It is `null` on every domain that is not catch-all.
- `catch_all.score` is the resolution score behind it. `method` is `pattern` when the address matched the domain's learned naming convention and `heuristic` otherwise. `reasons` lists up to five plain-language explanations you can show in your own interface.
- `domain.acceptAll` is `"yes"` on catch-all domains.

`sub_status` is `catch_all` for these addresses, unless a stronger reason applies first, such as `possible_trap`, `toxic` or `do_not_mail`.

## Act on each verdict

Treat the verdict as a sending decision, and match it to how much risk the mail can take.

| Verdict | Signup form | Marketing list | Cold outreach |
| --- | --- | --- | --- |
| `send_safe` | Accept | Keep | Send |
| `send_with_caution` | Accept | Send to engaged contacts first, watch bounces | Hold, or send in small batches |
| `avoid` | Ask for another address | Remove | Remove |

For bulk jobs, download the `send_safe` segment: every `deliverable` address plus catch-all addresses with a score of 65 or higher, with disposable and role addresses left out.

cURL:

```bash
curl "https://api.rocketverifier.com/v1/jobs/$JOB_ID/download?filter=send_safe" \
  -H "Authorization: Bearer $ROCKETVERIFIER_API_KEY" \
  -o send-safe.csv
```

Connect SendGrid, Mailgun or Postmark to feed real bounces back into the score. Hard bounces sharpen the verdicts for the domains you mail, and go straight onto your suppression list. See the [Bounce Guarantee](https://docs.rocketverifier.com/integrations/bounce-guarantee).

## How result versions change the status

The verdict is the same in every version; only the `status` label changes.

| Result version | `status` of a catch-all address | Charged |
| --- | --- | --- |
| `2026-11-01` (current) | `risky` | 1 credit |
| `2025-01-01` (legacy) | `unknown` | 1 credit |

Under `2025-01-01`, a catch-all address shares the `unknown` status with transient failures, but unlike them it is charged and carries a verdict. Read `sub_status` or `domain.acceptAll` to tell them apart, or send `RocketVerifier-Version: 2026-11-01`. A role address on a catch-all domain is `risky` in both versions. The [result versions page](https://docs.rocketverifier.com/versioning) covers the header and key defaults.

## Next steps

- [Reading results](https://docs.rocketverifier.com/results)
Every status and sub_status, what it costs and what to do with it.
- [Clean a list](https://docs.rocketverifier.com/guides/list-cleaning)
Download send-safe segments from a bulk job.

## Frequently asked questions

### Are catch-all results charged?

Yes, 1 credit, because the domain gave a real answer and every catch-all result carries a per-address verdict. This applies under both result versions, including 2025-01-01 where the status reads unknown.

### Why is a catch-all address risky and not deliverable?

The server accepts every recipient, so its answer says nothing about the specific mailbox. Only the resolution score separates real mailboxes from guesses, so the status stays risky and the verdict tells you what to do.

### Which catch-all addresses are safe to send to?

Addresses with catch_all_verdict send_safe, which needs a resolution score of 65 or higher. Download a job with filter=send_safe to get every deliverable address plus the catch-all addresses that score 65 or more, without disposable or role addresses.

### How do I find the catch-all addresses in an old integration that reads status?

Read domain.acceptAll, which is "yes" on catch-all domains in every result version, or sub_status, which is catch_all. Under result version 2025-01-01 these addresses report status unknown even though they were charged.
