Getting validation results

To retrieve the status and the eventual results of a particular email validation job, the client asks Verifalia for an updated job snapshot by issuing an HTTP GET request against the

/email-validations/{id}

sub-resource, where id is the unique ID generated by Verifalia upon receiving the email validation request.

The API replies back with an object representing the job snapshot of the requested job, along with all of the validated entries, if available. Should the validation be still in progress, the system would reply with an HTTP 202 (Accepted) status code and the client should reissue the request at a later time to retrieve an updated job snapshot: advanced API consumers may take advantage of the estimated remaining time indication, if available, to limit the number of pollings.

v2.4+ It is possible to ask the API to wait internally for the job completion, with the goal of minimizing the number of polling requests, by way of the waitTime query string parameter, which defines the number of milliseconds to wait for a given email verification job completion. The parameter accepts a value between 0 (the default value), meaning the API will never wait for the job completion, and 30000, meaning the API will wait for up to 30 seconds for the job completion. Under certain circumstances, the API may choose to ignore this parameter and consider a lower waiting time (or no waiting time at all) instead.

Instead of requesting a full job snapshot, advanced API consumers may want to just retrieve its overview: for this, one should issue an HTTP GET request against the

/email-validations/{id}/overview

sub-resource, where id is the unique ID generated by Verifalia upon receiving the email validation request.

The API replies back with an object representing the job overview of the requested job, with the same HTTP status codes logic followed for the job snapshot mentioned above.

Retrieve an email validation job
Language:

curl -u username:password \
    --compressed \
    https://api.verifalia.com/v2.6/email-validations/54375b5b-a399-4bc4-abd8-b8c02e109e53

var verifalia = new VerifaliaRestClient("username", "password");

// By default, GetAsync() automatically waits for job completion

var job = await verifalia
    .EmailValidations
    .GetAsync(Guid.Parse("54375b5b-a399-4bc4-abd8-b8c02e109e53"));

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

Validation job = verifalia
    .getEmailValidations()
    .get("54375b5b-a399-4bc4-abd8-b8c02e109e53");

const verifalia = new VerifaliaRestClient({
    username: 'username',
    password: 'password'
});

const job = await verifalia
    .emailValidations
    .get('54375b5b-a399-4bc4-abd8-b8c02e109e53');

use Verifalia\VerifaliaRestClient;
use Verifalia\VerifaliaRestClientOptions;

$verifalia = new VerifaliaRestClient([
    VerifaliaRestClientOptions::USERNAME => 'your-username-here',
    VerifaliaRestClientOptions::PASSWORD => 'your-password-here'
]);

$job = $verifalia->emailValidations->get('ec415ecd-0d0b-49c4-a5f0-f35c182e40ea');

package main

import (
    "fmt"
    "github.com/verifalia/verifalia-go-sdk/verifalia"
    "github.com/verifalia/verifalia-go-sdk/verifalia/emailValidation"
)

func main() {
    client := verifalia.NewClient("<USERNAME>", "<PASSWORD>") // See above

    // Retrieve an email validation job, given its Id

    validation, err := client.EmailValidation.Get("9ece66cf-916c-4313-9c40-b8a73f0ef872")

    if err != nil {
        panic(err)
    }
	
    if validation.Overview.Status == emailValidation.Status.Completed {
        // validation.Entries will have the validation results!
    } else {
        // What about having a coffee?
    }
}

verifalia = Verifalia::Client.new username: 'username', password: 'password'

job_id = 'ec415ecd-0d0b-49c4-a5f0-f35c182e40ea'
job = verifalia.email_validations.get job_id

Job snapshots

In response to a new email validation request and whenever you request it directly, Verifalia replies with a JSON object representing the snapshot of the email validation job which includes its overview and, when available, its validated entries.

JSON structure

An email validation snapshot has the following JSON data structure:

Property	Description
`overview`	A structure with general details about the job. See structure details.
`entries?`	A structure with the validated email addresses and their results, when available. See structure details.

Job overviews

A job overview includes the general details about an email validation job, such us its auto-generated ID, name and total number of email addresses.

While a job overview is already included in every job snapshot, advanced API consumers may want to just retrieve the former, for performance reasons: for this, they can issue an HTTP GET request against the

/email-validations/{id}/overview

sub-resource, where id is the unique ID generated by Verifalia upon receiving the email validation request.

The API replies back with an object representing the job overview of the requested job, with the same HTTP status codes logic followed for the job snapshot.

v2.4+ It is possible to ask the API to wait internally for the job completion, with the goal of minimizing the number of polling requests, by way of the waitTime query string parameter, which defines the number of milliseconds to wait for a given email verification job completion. The parameter accepts a value between 0 (the default value), meaning the API will never wait for the job completion, and 30000, meaning the API will wait for up to 30 seconds for the job completion. Under certain circumstances, the API may choose to ignore this parameter and consider a lower waiting time (or no waiting time at all) instead.

Retrieve a job overview
Language:

curl -u username:password \
    --compressed \
    https://api.verifalia.com/v2.6/email-validations/54375b5b-a399-4bc4-abd8-b8c02e109e53/overview

var verifalia = new VerifaliaRestClient("username", "password");

// By default, GetOverviewAsync() automatically waits for job completion

var jobOverview = await verifalia
    .EmailValidations
    .GetOverviewAsync(Guid.Parse("54375b5b-a399-4bc4-abd8-b8c02e109e53"));

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

ValidationOverview jobOverview = verifalia
    .getEmailValidations()
    .getOverview("54375b5b-a399-4bc4-abd8-b8c02e109e53");

// The Javascript SDK does not support this feature yet.

// The PHP SDK does not support this feature yet.

// The Go SDK does not support this feature yet.

# The Ruby SDK does not support this feature yet.

JSON structure

A job overview has the following JSON structure:

Property	Description
`id`	A `string` representing the unique identifier for the job which Verifalia generates upon receiving an email validation request.
`status`	A `string` with the status of the whole job. Can be one of the following values: `InProgress`, meaning the job is being processed by Verifalia `Completed`, meaning the job has been completed and its validated email addresses are available `Deleted`, meaning the job has been deleted `Expired`, meaning the job is expired
`name?`	A `string` with the user-defined name eventually given to this job at the time of its submission: used for your own internal reference.
`owner`	A `string` representing the unique identifier of the user which created the job.
`clientIP`	A `string` with the IP address of the API consumer which created the job.
`quality`	A `string` with the name of the results quality level requested for the job; can be one of `Standard`, `High` and `Extreme` (or other values for custom quality levels).
`deduplication`	A `string` with the name of the deduplication algorithm requested for the job; can be one of `Off`, `Safe` and `Relaxed` v2.1+.
`noOfEntries`	The `number` of email addresses included in this job.
`createdOn`	A `string` representing the timestamp of the creation of the job, in the ISO 8601 format.
`submittedOn?`	A `string` representing the timestamp of the eventual submission of the job, in the ISO 8601 format.
`completedOn?`	A `string` representing the timestamp of the eventual completion of the job, in the ISO 8601 format.
`priority?`	A `number` representing the priority (speed) of a validation job relative to the parent Verifalia account. If there are multiple concurrent validation jobs in an account, this value allows you to adjust the processing speed of a specific job in comparison to others. The valid range for this priority spans from `0` (lowest) to `255` (highest), with `127` representing normal priority. If not specified, Verifalia processes all concurrent validation jobs for an account at the same speed.
`retention` v2.1+	A `string` with the data retention period to observe for the validation job, expressed in the format `dd.hh:mm:ss` (where `dd`: days, `hh`: hours, `mm`: minutes, `ss`: seconds); the initial `dd.` part is added only for periods of more than 24 hours. Verifalia deletes the job and its data once its retention period is over, starting to count when the job gets completed.
`progress?.percentage`	The overall progress percentage for the job, when available, expressed as a `number` between `0` and `1`.
`progress?.estimatedTimeRemaining?`	A `string` representing the estimated remaining time for completing the email validation job, expressed in the format `dd.hh:mm:ss` (where `dd`: days, `hh`: hours, `mm`: minutes, `ss`: seconds); the initial `dd.` part is added only for huge lists requiring more than 24 hours to complete.

Job overview structure example

{
    "id": "18f5a933-af67-421c-b63a-1cbee297fa19",
    "status": "Completed",
    "owner": "c86d09f2-c0d4-4582-bc3e-bc97fdbb6579",
    "clientIP": "2.21.41.70",
    "quality": "Standard",
    "deduplication": "Off",
    "noOfEntries": 1,
    "createdOn": "2023-01-21T08:52:21.53Z",
    "submittedOn": "2023-01-21T08:52:21.53Z",
    "completedOn": "2023-01-21T08:52:21.757Z",
    "retention": "00:05:00"
}

Job entries

With the term job entries we refer to a structure which contains data about the validated email address(es) of an email validation job, along with any eventual metadata.

When returned as part of a job snapshot, this structure contains all of the validated email addresses for the job, where available, and no pagination is needed.

When returned upon requesting the entries of a job, this structure may contain a portion (zero or more) of the validated email addresses and the API consumer may need to issue additional requests to retrieve all of the entries of the set, according to the pagination metadata.

While a job entries structure is already included in completed job snapshots (and comes with every entry of the job, with no need for pagination), advanced API consumers may want to retrieve a portion of the entries for a job, for performance reasons (such as for lists with millions of email addresses), memory limitations at the API consumer side or for filtering purposes.

To do that, the Verifalia API allows to issue an HTTP GET request against the

/email-validations/{id}/entries

sub-resource, where id is the unique ID generated by Verifalia upon receiving the email validation request.

The API replies back with an object representing the entries of the requested job, with the same HTTP status codes logic followed for the job snapshot.

v2.4+ It is possible to ask the API to wait internally for the job completion, with the goal of minimizing the number of polling requests, by way of the waitTime query string parameter, which defines the number of milliseconds to wait for a given email verification job completion. The parameter accepts a value between 0 (the default value), meaning the API will never wait for the job completion, and 30000, meaning the API will wait for up to 30 seconds for the job completion. Under certain circumstances, the API may choose to ignore this parameter and consider a lower waiting time (or no waiting time at all) instead.

Retrieve job entries
Language:

# curl can retrieve a single result page at a time.
curl -u username:password \
    --compressed \
    https://api.verifalia.com/v2.6/email-validations/54375b5b-a399-4bc4-abd8-b8c02e109e53/entries

var verifalia = new VerifaliaRestClient("username", "password");

// Uses the C# 8.0 async enumerable feature; for previous language
// versions please check the SDK help.

var entries = verifalia
    .EmailValidations
    .ListEntriesAsync(Guid.Parse("54375b5b-a399-4bc4-abd8-b8c02e109e53"));

await foreach (var entry in entries)
{
    // TODO: Use the validated entry
}

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

Iterable<ValidationEntry> validationEntries = verifalia
    .getEmailValidations()
    .listEntries("54375b5b-a399-4bc4-abd8-b8c02e109e53");

for (ValidationEntry validationEntry : validationEntries) {
    // ...
}

// The Javascript SDK does not support this feature yet.

// The PHP SDK does not support this feature yet.

// The Go SDK does not support this feature yet.

# The Ruby SDK does not support this feature yet.

Filtering entries

Verifalia allows to filter validated entries of a completed email validation job by their status codes (for example, only the email addresses whose status code is Success or ServerIsCatchAll); it is also prossible to reverse the condition and get all the entries excluding the ones with certain status code(s).

To do that, an API consumer can pass any of the following keys via query string:

Key	Description
`status`	One or more email validation status codes representing the only values you wish to get from the API. Multiple values are separated with the comma (`,`) symbol.
`status:exclude`	One or more email validation status codes representing the values you wish to exclude from the API result. Multiple values are separated with the comma (`,`) symbol.

Retrieve filtered job entries
Language:

# curl can retrieve a single result page at a time.

curl -u username:password \
    --compressed \
    "https://api.verifalia.com/v2.6/email-validations/54375b5b-a399-4bc4-abd8-b8c02e109e53/entries?status=Success,ServerIsCatchAll"

var verifalia = new VerifaliaRestClient("username", "password");

// Uses the C# 8.0 async enumerable feature; for previous language
// versions please check the SDK help.

var entries = verifalia
    .EmailValidations
    .ListEntriesAsync(Guid.Parse("54375b5b-a399-4bc4-abd8-b8c02e109e53"),
        new ValidationEntryListingOptions
        {
            StatusFilter = new ValidationEntryStatusMatchPredicate
            {
                IncludedValues = new[]
                {
                    ValidationEntryStatus.Success,
                    ValidationEntryStatus.ServerIsCatchAll
                }
            }
        });

await foreach (var entry in entries)
{
    // TODO: Use the validated entry
}

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

Iterable<ValidationEntry> validationEntries = verifalia
    .getEmailValidations()
    .listEntries("54375b5b-a399-4bc4-abd8-b8c02e109e53",
        ValidationEntryListingOptions
            .builder()
            .statuses(
                new SetInclusionPredicate<>(ValidationEntryStatus.Success,
                    ValidationEntryStatus.ServerIsCatchAll))
            .build());

for (ValidationEntry validationEntry : validationEntries) {
    // ...
}

// The Javascript SDK does not support this feature yet.

// The PHP SDK does not support this feature yet.

// The Go SDK does not support this feature yet.

# The Ruby SDK does not support this feature yet.

Limiting entries

It is also possible to control the maximum number of validated entries returned by the API, so that API consumers with a low amount of memory can handle them in a streaming fashion instead of having to pre-allocate all the entries in memory at a time - a feature particularly useful in environments with constrained resources (e.g. embedded devices, mini/micro VPS).

To do that, an API consumer can pass the following key via query string:

Key	Description
`limit`	An integer number specifying the desired maximum amount of validated entries to be returned in a single results page; subsequent / previous pages can be retrieved as described in the paginated results, optionally in conjunction with the `limit` parameter to keep getting a limited amount of results.

The API endpoints may choose to ignore the limit parameter if its value is too low or too high or for other internal reasons.

Using many requests with small limits will not speed up, or slowdown for that matter, the Verifalia APIs; using many small requests will however have more overhead on your network connection.

Retrieve limited job entries
Language:

# curl can retrieve a single result page at a time.

curl -u username:password \
    --compressed \
    "https://api.verifalia.com/v2.6/email-validations/54375b5b-a399-4bc4-abd8-b8c02e109e53/entries?limit=1000"

var verifalia = new VerifaliaRestClient("username", "password");

// Uses the C# 8.0 async enumerable feature; for previous language
// versions please check the SDK help.

var entries = verifalia
    .EmailValidations
    .ListEntriesAsync(Guid.Parse("54375b5b-a399-4bc4-abd8-b8c02e109e53"),
        new ValidationEntryListingOptions
        {
            // ListEntriesAsync() will automatically iterate over all the
            // result pages, thus the specified Limit will only be used
            // internally to the SDK and not as a way to constrain the
            // overall number of returned items. 
            Limit = 1000
        });

await foreach (var entry in entries)
{
    // TODO: Use the validated entry
}

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

Iterable<ValidationEntry> validationEntries = verifalia
    .getEmailValidations()
    .listEntries("54375b5b-a399-4bc4-abd8-b8c02e109e53",
        ValidationEntryListingOptions
            .builder()
            // listEntries() will automatically iterate over all the
            // result pages, thus the specified limit will only be used
            // internally to the SDK and not as a way to constrain the
            // overall number of returned items. 
            .limit(1000)
            .build());

for (ValidationEntry validationEntry : validationEntries) {
    // ...
}

// The Javascript SDK does not support this feature yet.

// The PHP SDK does not support this feature yet.

// The Go SDK does not support this feature yet.

# The Ruby SDK does not support this feature yet.

Getting an entry from its index

API consumers may need to retrieve data for a specific validated entry, starting from its zero-based index; while useless for jobs with a low number of items (since retrieving all of the entries for a job would be easier), this feature can be useful whenever it is required to retrieve a validated entry in a random, non sequential fashion, for larger lists (such as for reporting and interactive viewing purposes).

The Verifalia API supports this scenario by way of an additional operation, where an API consumer issue an HTTP GET request against the following sub-resource:

/email-validations/{id}/entries/{index}

Where id is the unique ID generated by Verifalia upon receiving the email validation request and index is the zero-based index of the required entry in the whole email validation job.

Verifalia replies with an HTTP 303 (see other) status code, along with an HTTP Location header pointing at a job entries page which contains the required item.

v2.4+ It is possible to ask the API to wait internally for the job completion, with the goal of minimizing the number of polling requests, by way of the waitTime query string parameter, which defines the number of milliseconds to wait for a given email verification job completion. The parameter accepts a value between 0 (the default value), meaning the API will never wait for the job completion, and 30000, meaning the API will wait for up to 30 seconds for the job completion. Under certain circumstances, the API may choose to ignore this parameter and consider a lower waiting time (or no waiting time at all) instead.

Locate a job entries page by entry index
Language:

# curl automatically follows 303 redirects, so we will get the result
# entries page for the specified index, here:

curl -u username:password \
    --compressed \
    https://api.verifalia.com/v2.6/email-validations/54375b5b-a399-4bc4-abd8-b8c02e109e53/entries/42

// The .NET SDK does not support this feature yet.

// The Java SDK does not support this feature yet.

// The Javascript SDK does not support this feature yet.

// The PHP SDK does not support this feature yet.

// The Go SDK does not support this feature yet.

# The Ruby SDK does not support this feature yet.

JSON structure

The job entries JSON structure derives from the common paginated results structure described above, where each data item has this JSON structure:

Property	Description
`index`	A `number` with the zero-based index of the entry, with respect to the whole job; this value is mostly useful in the event the API consumer requests a filtered entries set.
`inputData`	A `string` with the original input data submitted for validation.
`classification`	A `string` representing the name of the classification for the email validation, which groups related email validation status codes; can be a custom string or one of the following values: `Deliverable`, meaning the email address should be able to accept messages into its mailbox; `Undeliverable`, meaning the email address is believed to be invalid or inactive; `Risky`, meaning the email address appears to be valid but we are not completely sure about its quality and deliverability; `Unknown`, meaning we were unable to validate the email address for technical reasons.
`status`	A `string` representing the name of the specific result status for the email validation. It can be any of the validation status codes described below.
`emailAddress?`	A `string` with the eventually recognized email address, without any comment or FWS (folding white space) symbol.
`emailAddressLocalPart?`	A `string` with the local part of the email address.
`emailAddressDomainPart?`	A `string` with the domain part of the email address.
`asciiEmailAddressDomainPart?`	A `string` with the domain part of the email address converted to ASCII, using the punycode algorithm.
`hasInternationalMailboxName?`	A `boolean` which, if set, signals the email address has an international, non-ASCII mailbox name.
`hasInternationalDomainName?`	A `boolean` which, if set, signals the email address has an international, non-ASCII domain name.
`isDisposableEmailAddress?`	A `boolean` which, if set, signals the email address is a temporary, throw-away, disposable address.
`isRoleAccount?`	A `boolean` which, if set, signals the local part of the email address is possibly referring to a well-known group of people, instead of a single person.
`isFreeEmailAddress?`	A `boolean` which, if set, signals the email address is handled by a well-known Free email service provider (e.g. Gmail, Yahoo, Outlook / Live / Hotmail, etc.).
`syntaxFailureIndex?`	A `number` which, if set, refers to the zero-based position of the first syntax error in the `inputData` property.
`suggestions?` v2.5+	A `string[]` which, if set, contains the AI-generated alternative spellings that are more likely to be the correct email.
`custom?`	A `string` with the eventual custom data included with the entry at the job submission time.
`duplicateOf?`	A `number` with the eventual zero-based index of the entry which appears to be duplicated by this item. Only present when the `status` property equals to `Duplicate`.
`completedOn`	A `string` representing the timestamp of the eventual completion of the entry, in the ISO 8601 format.

Simple job entries structure example

{
    "data": [
        {
            "index": 0,
            "inputData": "batman@gmail.com",
            "completedOn": "2019-07-31T10:49:20.5957669Z",
            "emailAddress": "batman@gmail.com",
            "asciiEmailAddressDomainPart": "gmail.com",
            "emailAddressLocalPart": "batman",
            "emailAddressDomainPart": "gmail.com",
            "hasInternationalDomainName": false,
            "hasInternationalMailboxName": false,
            "isDisposableEmailAddress": false,
            "isRoleAccount": false,
            "isFreeEmailAddress": true,
            "status": "Success",
            "classification": "Deliverable"
        }
    ]
}

Job entries structure example with multiple email addresses

{
    "meta": {
        "cursor": "14l/srjfPJo7fP0hFuHsXA==",
        "isTruncated": true
    },
    "data": [
        {
            "index": 0,
            "inputData": "batman@gmail.com",
            "completedOn": "2019-07-31T10:49:20.5957669Z",
            "emailAddress": "batman@gmail.com",
            "asciiEmailAddressDomainPart": "gmail.com",
            "emailAddressLocalPart": "batman",
            "emailAddressDomainPart": "gmail.com",
            "hasInternationalDomainName": false,
            "hasInternationalMailboxName": false,
            "isDisposableEmailAddress": false,
            "isRoleAccount": false,
            "isFreeEmailAddress": true,
            "status": "Success",
            "classification": "Deliverable"
        },
        {
            // ...
        },
        {
            "index": 999,
            "inputData": "steve.vai@best.music",
            "completedOn": "2019-07-31T10:49:23.1029945Z",
            "emailAddress": "steve.vai@best.music",
            "asciiEmailAddressDomainPart": "best.music",
            "emailAddressLocalPart": "steve.vai",
            "emailAddressDomainPart": "best.music",
            "hasInternationalDomainName": false,
            "hasInternationalMailboxName": false,
            "isDisposableEmailAddress": false,
            "isRoleAccount": false,
            "isFreeEmailAddress": false,
            "status": "DomainDoesNotExist",
            "classification": "Undeliverable"
        }
    ]
}

Exporting entries v2.3+

The API allows to export the email verification results in different output formats, with the goal of generating a human-readable representation of our data. While the output schema (columns / labels / data format) is fairly complete, you should always consider it as subject to change: always get your verification results in JSON format whenever you must rely on a stable output schema.

To export verification entries in a format other than JSON, an API consumer can specify any of the following values through the Accept header:

Output format	`Accept` header value
Comma-Separated Values (CSV)	`text/csv`
Microsoft Excel (.xlsx)	`application/vnd.openxmlformats-officedocument.spreadsheetml.sheet`
Microsoft Excel 97-2003 (.xls)	`application/vnd.ms-excel`

Export job entries as a CSV file
Language:

curl -u username:password \
    --compressed \
    --header "Accept: text/csv" \
    https://api.verifalia.com/v2.6/email-validations/54375b5b-a399-4bc4-abd8-b8c02e109e53/entries

var verifalia = new VerifaliaRestClient("username", "password");

var jobId = Guid.Parse("54375b5b-a399-4bc4-abd8-b8c02e109e53");

// Export the job to a stream

await using var stream = await verifalia
    .EmailValidations
    .ExportEntriesAsync(jobId, ExportedEntriesFormat.ExcelXlsx);

// Open the target output file stream

await using var target = File.Open(@"./export.xlsx",
    FileMode.CreateNew);

// Copy the source into the target stream

stream.CopyToAsync(target);

// The Java SDK does not support this feature yet.

const verifalia = new VerifaliaRestClient({
    username: 'username',
    password: 'password'
});

const exportedData = await verifalia
    .emailValidations
    .export('dc21630a-6773-4bd0-b248-15e8b50c0d3e',
        MimeContentType_TextCsv);

// In Node.js: save it to a file

exportedData.pipe(fs.createWriteStream('/home/lbanfi/my-list.csv'));

// Browser-only: show it inside an IFRAME

document
    .getElementByID('myIFrame')
    .src = exportedData.toBlobURL(MimeContentType_TextCsv);

// The PHP SDK does not support this feature yet.

// The Go SDK does not support this feature yet.

job_id = 'ec415ecd-0d0b-49c4-a5f0-f35c182e40ea'
format = 'text/csv'

data = verifalia.email_validations.export job_id, format

File.open('./export.csv', 'wb') do |fp|
  fp.write(data)
end

Validation status codes

Verifalia defines several different status codes, where each value signals a successful validation or a particular issue which arised while validating an email address.

API consumers must be tolerant to new, unknown status codes and treat them as undetermined results, to allow for future expansion of the supported values.

Current status codes include the following values:

Status code	Description
`AtSignNotFound`	Invalid email format: the `@` symbol, used to separate the local part from the domain part of the address, has not been found.
`CatchAllValidationTimeout`	Validation failed due to a timeout while verifying the rejection of a fake email address by the mail server. Trying a higher results quality level is likely to provide a definitive response.
`DnsConnectionFailure`	Email verification failed due to a socket connection error while querying the DNS server(s) for records about the email address domain. Trying a higher results quality level is likely to provide a definitive response.
`DnsQueryTimeout`	A timeout occurred while querying the DNS servers for records about the domain. Trying a higher results quality level is likely to provide a definitive response.
`DomainDoesNotExist`	Invalid email address: the domain of the email address does not exist.
`DomainIsMisconfigured`	Invalid email address: the domain lacks valid DNS records and cannot receive messages from external hosts on the Internet.
`DomainHasNullMx` v2.1+	Invalid email address, the domain intentionally does not have any mail servers configured to receive email messages.
`DomainIsWellKnownDea`	High-risk email type: the email address is associated with a well-known disposable email address (DEA). We strongly recommend removing DEAs from your lists.
`DomainPartCompliancyFailure`	Invalid email format: the domain part of the email address does not comply with IETF standards.
`DoubleDotSequence`	Invalid email format: an invalid sequence of two adjacent dots has been found.
`Duplicate`	The email is a duplicate of another entry that has been previously verified in this list; the `duplicateOf` property contains the zero-based index of its first occurrence.
`InvalidAddressLength`	Invalid email format: the email address has an invalid total length.
`InvalidCharacterInSequence`	Invalid email format: an invalid character has been detected in the provided sequence.
`InvalidEmptyQuotedWord`	Invalid email format: an invalid quoted word with no content has been found.
`InvalidFoldingWhiteSpaceSequence`	Invalid email format: an invalid folding white space (FWS) sequence has been found.
`InvalidLocalPartLength`	Invalid email format: the local part of the email address has an invalid length.
`InvalidWordBoundaryStart`	Invalid email format: a new word boundary has been detected at an invalid position.
`IspSpecificSyntaxFailure`	Invalid email format: the email address does not comply with the specific formatting requirements of the target service provider.
`LocalEndPointRejected`	Validation failed because the external mail exchanger rejected the local endpoint. Trying a higher results quality level is likely to provide a definitive response.
`LocalSenderAddressRejected`	Validation failed because the external mail exchanger rejected the local sender address. Trying a higher results quality level is likely to provide a definitive response.
`MailboxDoesNotExist`	Invalid email address: the mailbox for the email address does not exist.
`MailboxHasInsufficientStorage`	The mailbox for the email address is either over its storage quota, or the mail exchanger has insufficient system storage.
`MailboxIsDea`	Risky email type: the email address is associated with a disposable / throw-away mailbox. We recommend removing disposable email addresses (DEAs) from your lists.
`MailboxTemporarilyUnavailable`	Validation failed because the requested mailbox is temporarily unavailable. This doesn't necessarily mean the mailbox doesn't exist; it's often a response from mail exchangers with greylisting enabled. Trying a higher results quality level is likely to provide a definitive response.
`MailboxValidationTimeout`	Validation failed due to a timeout while verifying the existence of the mailbox. Trying a higher results quality level is likely to provide a definitive response.
`MailExchangerIsHoneypot`	High-risk email type: the email address is a honeypot (also known as spamtrap). We strongly advise removing honeypots from your lists.
`MailExchangerIsParked` v2.4+	High-risk email type: the email address is served by a parked or inactive mail exchanger, which may potentially resell collected email data. We strongly recommend removing this address from your lists.
`MailExchangerIsWellKnownDea`	High-risk email type: the email address is associated with a well-known disposable email address provider (DEA). We strongly recommend removing DEAs from your lists.
`OverrideMatch` v2.5+	Input data matches a custom classifier rule expression of the submitter.
`ServerDoesNotAllowMultipleRecipients`	Possibly risky email type: the external mail exchanger may accept fake and nonexistent email addresses. Therefore, the provided email address may not exist, and the existence of the individual mailbox could not be verified. Trying a higher results quality level is likely to provide a definitive response.
`ServerDoesNotSupportInternationalMailboxes`	Invalid email address: the external mail exchanger does not support international mailbox names. To support this feature, mail exchangers must comply with RFC 5336 and announce support for both the 8BITMIME and UTF8SMTP protocol extensions.
`ServerIsCatchAll`	Possibly risky email type: the external mail exchanger accepts fake and nonexistent email addresses. Therefore, the provided email address may not exist, and the existence of the individual mailbox cannot be verified.
`ServerTemporaryUnavailable`	Validation failed because the external mail exchanger is temporarily unavailable. Trying a higher results quality level is likely to provide a definitive response. Note: the presence of a typo in this status code is intentional and serves the purpose of maintaining backward compatibility with older API clients.
`SmtpConnectionFailure`	Possibly invalid email address: a socket connection error occurred while trying to connect to the mail exchanger that serves the email address domain. Trying a higher results quality level is likely to provide a definitive response.
`SmtpConnectionTimeout`	Possibly invalid email address: a timeout occurred while trying to connect to the mail exchanger that serves the email address domain. Trying a higher results quality level is likely to provide a definitive response.
`SmtpDialogError`	Validation failed because the external mail exchanger replied in a non-standard way. Trying a higher results quality level is likely to provide a definitive response.
`Success`	Valid email, with no high-risk factors detected: safe to send mail, which completes our multi-step verification process successfully.
`UnacceptableDomainLiteral`	Invalid email: the domain literal of the email address cannot accept messages from the Internet. While Verifalia supports them, domain literals are quite rare nowadays.
`UnbalancedCommentParenthesis`	Invalid email format: the number of parentheses used to open comments is not equal to the number used to close them.
`UnexpectedQuotedPairSequence`	Invalid email format: an unexpected quoted pair sequence has been found within a quoted word.
`UnhandledException`	Validation failed due to unexpected technical issues during the processing of this email address. Retry may provide a definitive response.
`UnmatchedQuotedPair`	Invalid email format: a quoted pair within a quoted word is not properly closed.

Getting validation results

Not a developer?