# Catchall Email Verification - Relentless Identity (`codemaggot/relentless-identity-api`) Actor

Relentless Identity is the best API to date for finding and verifying work emails with features including alias resolution, multi-domain discovery, and catchall resolution.

- **URL**: https://apify.com/codemaggot/relentless-identity-api.md
- **Developed by:** [Code Maggot](https://apify.com/codemaggot) (community)
- **Categories:** Lead generation, Integrations, Other
- **Stats:** 19 total users, 10 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.90 / 1,000 client probes

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Relentless Identity Email Finder & Verifier Actor

**Overview**\
Find and verify emails at scale using Relentless Identity's live identity-first verification API. This Actor helps SaaS teams, ecommerce operators, sales teams, marketers, and data teams discover likely work emails, verify existing addresses, resolve aliases, detect catch-all behavior, and identify supported corporate identity providers behind a domain.

Relentless Identity is built for modern email infrastructure where SMTP-only checks often fail. Instead of relying on stale lookup tables, it combines live provider and mailbox signals to return compact, actionable results for finder and verification workflows.

#### Why Relentless Identity?

1. **Live Identity Verification**\
   Verify emails using live identity and routing signals instead of purchased databases, recycled enrichment tables, or stale cached records.
2. **Finder + Probe Workflows**\
   Use the Finder flow to discover likely work emails for a person and company, or use Probe to verify a known email address.
3. **Modern Infrastructure Coverage**\
   Resolve aliases, detect catch-all behavior, inspect MX hosts, and identify identity providers such as Okta, Microsoft Entra ID, Google Workspace, OneLogin, Auth0, Ping Identity, and others.

#### Finder vs. Probe

| Tool | Endpoint | Best For | Notes |
|------|----------|----------|-------|
| **Finder** | `/client/attempt` | Finding likely work emails from a person + company/domain input | Includes alias resolution, catch-all resolution, and multi-domain discovery for work email discovery. |
| **Probe** | `/client/probe` | Verifying a specific email address | Works for work and non-work emails. Alias resolution applies to work-email workflows. |

#### Common Use Cases

- **Sales & Marketing Prospecting**\
  Find verified work emails for decision-makers, enrich lead lists, and reduce bounce risk before outreach.
- **CRM & Data Enrichment**\
  Fill missing work email fields and validate existing records before syncing to HubSpot, Salesforce, Clay, or custom pipelines.
- **Email List Cleaning**\
  Use Probe to validate existing lists, including ecommerce or SaaS customer emails that may not be corporate work emails.
- **Fraud, Risk & Identity Checks**\
  Map addresses to identity evidence, detect aliases, and understand whether an email is backed by real provider-side signals.

#### Automate Your Workflow

- **Webhook Integration**\
  Push Actor results to Zapier, Make, n8n, Slack, or your CRM using Apify webhooks.
- **Scheduled Verification**\
  Run recurring jobs to clean lead lists, refresh CRM records, or re-check high-value email addresses.
- **Batch Processing**\
  Call the Actor repeatedly from your own workflow or queue if you need many Finder or Probe requests.

***

### Input Examples

Provide either `fullName` + `domain` for Finder, or `email` for Probe. Mixing them is an error.

#### Finder Input

Use Finder when you want to discover the most likely work email for a person at a company.

```json
{
  "fullName": "Jane Doe",
  "domain": "acme.com"
}
```

#### Probe Input

Use Probe when you already have an email address and want to verify whether it appears deliverable and identity-backed.

```json
{
  "email": "jane.doe@acme.com"
}
```

***

### Output Structure

Each Actor result is the Relentless Identity response returned by the backend.

#### Response Shape: `/client/attempt` (Finder)

```json
{
  "state": "deliverable",
  "outcome": "found",
  "address": "string",
  "alternatives": ["string"],
  "is_alias": true,
  "alias": {
    "original": "string",
    "resolved": "string"
  },
  "is_catchall": true,
  "identity_providers": [
    {
      "provider": "okta",
      "hostname": "company.okta.com"
    }
  ],
  "mx_hosts": [
    "string"
  ],
  "request_id": "string"
}
```

#### Response Shape: `/client/probe` (Probe)

```json
{
  "state": "deliverable",
  "outcome": "found",
  "address": "string",
  "is_alias": true,
  "alias": {
    "original": "string",
    "resolved": "string"
  },
  "is_catchall": true,
  "identity_providers": [
    {
      "provider": "okta",
      "hostname": "company.okta.com"
    }
  ],
  "mx_hosts": [
    "string"
  ],
  "request_id": "string"
}
```

***

### Key Data Points

| Field | What It Means | Use Case |
|-------|---------------|----------|
| `state` | Deliverability classification for the returned or verified address | Filter usable emails before outreach or import. |
| `outcome` | Whether the request produced a found/verified result | Route successful and unresolved records differently. |
| `address` | The discovered or verified email address | Save to CRM, enrichment table, or outreach tool. |
| `alternatives` | Additional valid identities found during Finder resolution (Finder only) | Expand outreach or retry against alternate addresses. |
| `is_alias` | Whether the email appears to be an alias | Understand whether the submitted address differs from the resolved identity. |
| `alias.original` | Original alias address | Audit alias resolution. |
| `alias.resolved` | Resolved identity-backed address | Prefer canonical or provider-backed address records. |
| `is_catchall` | Whether the domain appears to use catch-all behavior | Avoid treating SMTP acceptance alone as proof of a real inbox. |
| `identity_providers` | Detected identity provider signals | Understand the identity stack behind the domain. |
| `mx_hosts` | Mail exchanger hosts for the domain | Support deliverability, routing, and infrastructure analysis. |
| `request_id` | Unique request identifier | Debugging, support, and reconciliation. |

***

### FAQ

**Q: What is the difference between Finder and Probe?**\
A: Finder uses `/client/attempt` to discover a likely work email from person and company/domain inputs. Probe uses `/client/probe` to verify a specific email address.

**Q: Does Finder only work for work emails?**\
A: Finder is primarily designed for work email discovery.

**Q: Do I need to verify addresses returned by the finder?**\
A: No.

**Q: Can Probe verify non-work emails?**\
A: Yes.

**Q: Does Probe perform multi-domain discovery?**\
A: No. Probe verifies the specific email address you submit.

**Q: Does the Actor resolve aliases?**\
A: Yes, but alias resolution is limited to work-email workflows. Finder and work-email Probe results can return alias information through `is_alias` and the `alias.original` / `alias.resolved` fields.

**Q: Does it work with catch-all domains?**\
A: Yes. Relentless Identity is designed to interpret catch-all behavior and return more precise signals than SMTP-only checks.

**Q: How many free requests do I get?**\
A: Free-tier users pay the published list price above.

**Q: Is pricing the same on Relentless Identity's own platform?**\
A: No. Apify free-tier users pay list price, while paid tiers use the discounted pay-as-you-go pricing.

**Q: Can I use Relentless Identity outside Apify?**\
A: Yes. You can sign up directly on the Relentless Identity platform, start free, and use the native API or supported integrations outside Apify.

**Q: Are all Relentless Identity endpoints available in this Actor?**\
A: No. This Actor focuses on Finder and Probe. Other endpoints, such as job scheduling endpoints, are not exposed through the Apify Actor.

**Q: How fresh is the data?**\
A: Results are produced from live verification signals rather than stale lookup tables. Run scheduled jobs when you want to refresh a CRM, prospect list, or customer email list.

**Q: What should I do with uncertain or unresolved results?**\
A: Keep them separate from deliverable records, retry later if appropriate, or route them into a manual review workflow depending on your risk tolerance.

***

### Integration Code

Use the Apify API to run the Actor and return the dataset items directly.

```bash
curl "https://api.apify.com/v2/actors/codemaggot~relentless-identity-api/run-sync-get-dataset-items?format=json" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "jane.doe@acme.com"
  }'
```

If you prefer the run object first, use `run-sync` and then fetch the run's default dataset items.

***

### Learn More

- [Homepage](https://relentlessidentity.com)
- [Documentation](https://relentlessidentity.com/docs)
- [REST API Reference](https://relentlessidentity.com/docs/rest-api-reference)
- [MCP Reference](https://relentlessidentity.com/docs/mcp-reference)
- [Pricing](https://relentlessidentity.com/pricing)

***

*Stop guessing which emails are real. Find, verify, and resolve identities with live signals.*

# Actor input Schema

## `fullName` (type: `string`):

Required with Domain for Finder. Leave blank for Probe.

## `domain` (type: `string`):

Required with Full name for Finder. Leave blank for Probe.

## `email` (type: `string`):

Required for Probe. Leave Finder fields blank when using this.

## Actor input object example

```json
{}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("codemaggot/relentless-identity-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("codemaggot/relentless-identity-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call codemaggot/relentless-identity-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,codemaggot/relentless-identity-api"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/VxaBWofumxDQno2ad/builds/2EcYW8uRQw7MAoiAU/openapi.json