canonical: https://jentic.com/apis/emaillistverify.com/emaillistverify

# EmailListVerify API

Jentic publishes the only available OpenAPI specification for EmailListVerify API, keeping it validated and agent-ready. EmailListVerify is an email-validation service exposing 4 endpoints: single-email verification, bulk-list submission, bulk-file status lookup, and a disposable-email check. Authentication is an API key in the X-API-Key request header against https://apps.emaillistverify.com. The narrow surface is purpose-built for cleaning email lists before campaigns and rejecting disposable signups in real time.

## For AI agents

Validate single email addresses, submit bulk lists, check disposable status, and poll bulk-job progress with EmailListVerify. Authenticated with an API key in the X-API-Key header.

## Scope

Does not handle email sending, contact storage, or marketing campaigns - use for email-address verification, bulk list checks, and disposable-domain detection only.

## Capabilities

- Verify a single email synchronously via GET `/api/verifyEmail`
- Submit a bulk list of emails for verification with POST `/api/verifyApiEmailList`
- Poll bulk-verification job status at GET `/api/getApiFileInfo`
- Check whether a single address comes from a known disposable domain via GET `/api/disposable`
- Reject disposable-domain signups at the form layer to protect signup quality
- Clean a recipient list before a campaign to reduce hard bounces

## Use cases

### Real-Time Disposable Email Rejection

Block disposable and throw-away email signups by calling GET `/api/disposable` on the submitted address before account creation. The disposable check returns a boolean quickly and is cheaper than a full verification, so it suits high-traffic signup forms. Suitable for any signup flow seeing thousands of submissions per day where account quality matters.

Example prompt: On signup, call GET `/api/disposable` with email=user@example.com; if disposable=true, reject the form and prompt the user for a permanent email

### Pre-Campaign List Cleaning

Clean a recipient list before a marketing campaign by uploading the addresses with POST `/api/verifyApiEmailList`, polling GET `/api/getApiFileInfo` until complete, and filtering down to verified addresses. This is the recommended flow for lists larger than a few hundred where the synchronous verifier would be too slow or expensive.

Example prompt: POST a 25,000-address list to `/api/verifyApiEmailList`, poll `/api/getApiFileInfo` every minute until status=complete, then download the verified subset

### Inline Verification on CRM Import

When importing leads into a CRM, run each address through GET `/api/verifyEmail` before creating the contact record so the CRM only holds deliverable addresses. The synchronous endpoint returns a status that classifies the address (deliverable, undeliverable, risky, unknown) and lets the import job make a deterministic accept-or-skip decision.

Example prompt: For each lead in the import queue, call GET `/api/verifyEmail` and only create the contact if status is 'deliverable'

### AI Agent Integration via Jentic

Build an AI lead-enrichment agent that takes raw leads from a webform, validates each email through EmailListVerify, and forwards only deliverable leads to the sales pipeline. Through Jentic, the agent searches by intent, loads the verify schema, and executes without holding the X-API-Key in its prompt.

Example prompt: Search Jentic for 'verify a single email address with EmailListVerify', load the schema for GET `/api/verifyEmail`, and verify the latest webform email before creating a CRM lead

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/api/verifyEmail` | Verify a single email address |
| POST | `/api/verifyApiEmailList` | Submit a bulk list for verification |
| GET | `/api/getApiFileInfo` | Get bulk-verification file status |
| GET | `/api/disposable` | Check if an email is disposable |

## Key resources

- **Single Verification** — Synchronous verification of one email address
- **Bulk Verification** — Submit and poll bulk-verification jobs for large lists
- **Disposable Check** — Detect disposable or throw-away email domains

## Why Jentic

- **Setup:** Wiring EmailListVerify by hand means handling its API-key auth, setting the X-API-Key header on every call, and polling bulk file checks yourself. Through Jentic you install once, import the EmailListVerify API from the API Directory, store the API key once, and your agent calls it.
- **Permission scoping:** EmailListVerify checks take the address or list as a request or query value rather than a resource id in the URL path, so scope the agent by operation: limit it to the calls it needs, such as GET `/api/verifyEmail` and GET `/api/disposable.` You choose the operations it may call, so bulk list uploads are not included unless you add them.
- **Credential handling:** Your EmailListVerify API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'verify a single email' or 'check if an email is disposable', and Jentic returns the matching EmailListVerify operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Emailable API** — Emailable is a competing email-verification service with similar single and batch endpoints
- **ZeroBounce API** — ZeroBounce offers verification with deeper data points like activity and IP geolocation
- **NeverBounce API** — NeverBounce focuses on accept-rate guarantees for cleaned lists

## FAQ

### Why is there no official OpenAPI spec for EmailListVerify API?

EmailListVerify publishes its API reference as HTML at emaillistverify.com/api rather than as a versioned OpenAPI specification. Jentic generates and maintains this spec so AI agents and developers can call EmailListVerify via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the EmailListVerify API use?

EmailListVerify uses an API key in the X-API-Key request header. Through Jentic, the key is stored encrypted in the vault and injected at execution time so the agent never sees the raw key in its prompt or logs.

### Can I check whether an email is disposable?

Yes. GET `/api/disposable` returns a boolean indicating whether the address comes from a known disposable-email provider, which is the fastest way to block throw-away signups without spending a full verification credit.

### How do I bulk-verify a large list?

POST `/api/verifyApiEmailList` with the list returns a job identifier, and GET `/api/getApiFileInfo` reports the job status. Poll at one-minute intervals for lists larger than 10,000 addresses.

### How do I verify an email through EmailListVerify via Jentic?

Run the Jentic search query 'verify a single email address with EmailListVerify', load the input schema for GET `/api/verifyEmail`, then execute with the email to check. Jentic injects the X-API-Key at execution time.

### What is the difference between the single verify and disposable endpoints?

GET `/api/verifyEmail` performs a full deliverability check (syntax, domain, mailbox) and returns a status like deliverable or undeliverable; GET `/api/disposable` only flags whether the domain is on the disposable list. Use the disposable endpoint as a cheap pre-filter and the verify endpoint when full deliverability matters.

### Can I limit what my agent is allowed to do with the EmailListVerify API?

Yes. Because you run Jentic One yourself, your own rules decide which EmailListVerify operations and credentials the agent may use. Since EmailListVerify checks take the email address or list as a request value rather than a resource id in the URL path, you scope the agent by operation: allow only the calls it needs, such as GET `/api/verifyEmail` and GET `/api/disposable`, and leave out bulk uploads via POST `/api/verifyApiEmailList` and status polling via GET `/api/getApiFileInfo` unless you explicitly add them. The API key is held by your own instance and injected at execution time, so the agent can only reach the operations you have permitted.