Verifying email addresses

curl -u username:password \
    --compressed \
    -H "Content-Type: application/json" \
    -d '{ "entries": [ { "inputData": "batman@gmail.com" } ] }' \
    https://api.verifalia.com/v2.6/email-validations

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

// By default, SubmitAsync() automatically waits for the job completion

var job = await verifalia
    .EmailValidations
    .SubmitAsync("batman@gmail.com");

// Note: SubmitAsync() allows to specify the desired results quality and
// accepts arrays of email addresses as well: check its overloads for
// all the supported options.

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

// Option 1: submit the validation

Validation job = verifalia
    .getEmailValidations()
    .submit("batman@gmail.com");

// Option 2: submit the validation and wait for its completion

Validation job = verifalia
    .getEmailValidations()
    .submit("batman@gmail.com", new WaitingStrategy(true));

// Note: submit() allows to specify the desired results quality and
// accepts arrays of email addresses as well: check its overloads
// as well as the builder pattern exposed by the ValidationRequest
// class for all the supported options.

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

// By default, submit() automatically waits for the job completion

const job = await verifalia
    .emailValidations
    .submit('batman@gmail.com');

// Note: submit() allows to specify the desired results quality and
// accepts arrays of email addresses as well: check the docs for
// a list of all the supported options.

use Verifalia\VerifaliaRestClient;
use Verifalia\VerifaliaRestClientOptions;

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

// By default, submit() automatically waits for the job completion

$job = $verifalia->emailValidations->submit('batman@gmail.com');

// Note: submit() allows to specify the desired results quality and
// accepts arrays of email addresses as well: check the docs for
// all the supported options.

package main

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

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

    // Verifies an email address

    validation, err := client.EmailValidation.Run("batman@gmail.com")

    if err != nil {
        panic(err)
    }

    // Print some results

    entry := validation.Entries[0]
    fmt.Printf("%v => %v", entry.EmailAddress, entry.Classification)

    // Output:
    // batman@gmail.com => Deliverable
}

require 'verifalia'

# ...

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

# By default, submit() automatically waits for the job completion

job = verifalia.email_validations.submit 'batman@gmail.com'

// Note: submit() allows to specify the desired results quality and
// accepts arrays of email addresses as well: check the docs for
// a list of all the supported options.

curl -u username:password \
    --compressed \
    -F 'inputFile=@my-list.xls;type=application/vnd.ms-excel' \
    https://api.verifalia.com/v2.6/email-validations

// Initialize the request using the file to import

var request = new FileValidationRequest("./my-list.xls");

// Submit the validation and wait for its completion

var validation = await verifalia
    .EmailValidations
    .SubmitAsync(request);

// Note: SubmitAsync() allows to specify the desired results quality and
// accepts arrays of email addresses as well: also, the method allows to
// configure the import operation as needed (see the section below for
// the details).

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

FileValidationRequest request = new FileValidationRequest("my-list.xls",
    WellKnownMimeTypes.EXCEL_XLS);

// Submit the validation and wait for its completion

Validation validation = verifalia
    .getEmailValidations()
    .submit(request, new WaitingStrategy(true));

// Import the MIME content type for Excel files (just a string, for our convenience)

import { MimeContentType_ExcelXlsx } from 'verifalia/node/esm/index.mjs';

// Initialize the request using the file to import

const file = fs.createReadStream('/home/john/sample.xlsx');

// Submit the validation and wait for its completion

const result = await verifalia
    .emailValidations
    .submit({
        file: file,
        contentType: MimeContentType_ExcelXlsx,
        startingRow: 1,
        quality: 'high',
        deduplication: 'safe'
    });

// Note: submit() allows to specify the desired results quality and
// accepts arrays of email addresses as well: also, the method allows to
// configure the import operation as needed (see the section below for
// the details).

// The PHP SDK does not support importing files yet

package main

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

func main() {
    client := verifalia.NewClient("<USERNAME>", "<PASSWORD>") // See above
	
    // Verifies an Excel file with a list of email addresses

    thatFile, err := os.Open("that-file.xslx")
	
    if err != nil {
        panic(err)
    }

    validation, err = client.EmailValidation.RunFile(thatFile)

    if err != nil {
        panic(err)
    }

    // Print some results

    for _, entry := range validation.Entries {
        fmt.Printf("%v => %v\n",
            entry.EmailAddress,
            entry.Classification)
    }
}

# The Ruby SDK does not support importing files yet

curl -u username:password \
    --compressed \
    -F 'settings="{ \"startingRow\": 42 }";type=application/json' \
    -F 'inputFile=@my-list.txt;type=text/plain' \
    https://api.verifalia.com/v2.6/email-validations

var request = new FileValidationRequest("./contacts.txt")
{
    StartingRow = 2,
    LineEnding = LineEndingMode.CrLf
};

// Submit the validation and wait for its completion

var validation = await verifalia
    .EmailValidations
    .SubmitAsync(request);

// Note: SubmitAsync() allows to specify the desired results quality and
// accepts arrays of email addresses as well: also, the method allows to
// configure the import operation as needed (see the section below for
// the details).

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

FileValidationRequest request = new FileValidationRequest("my-list.txt",
    WellKnownMimeTypes.TEXT_PLAIN);

request.setStartingRow(42);

Validation validation = verifalia
    .getEmailValidations()
    .submit(request);

// Initialize the request using the file to import

const file = fs.createReadStream('/contacts.txt');

// Submit the validation and wait for its completion

const result = await verifalia
    .emailValidations
    .submit({
        file: file,
        contentType: 'text/plain',
        startingRow: 2,
        lineEnding: '\r\n'
    });

// Note: submit() allows to specify the desired results quality and
// accepts arrays of email addresses as well: also, the method allows to
// configure the import operation as needed (see the section below for
// the details).

// The PHP SDK does not support importing files yet

package main

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

func main() {
    client := verifalia.NewClient("<USERNAME>", "<PASSWORD>") // See above
	
    // Verifies a plain text file with a list of email addresses

    thatFile, err := os.Open("my-list.txt")
	
    if err != nil {
        panic(err)
    }

    // Specify which data Verifalia should process through the file options 
	
    fileOptions := emailValidation.FileSubmissionOptions{
        StartingRow: 42,
    }	

    validation, err = client.EmailValidation.RunFileWithOptions(thatFile,
        fileOptions,
        nil,
        nil)

    // ...
}

# The Ruby SDK does not support importing files yet

curl -u username:password \
    --compressed \
    -F 'settings="{ \"delimiter\": \";\", \"startingRow\": 2 }";type=application/json' \
    -F 'inputFile=@my-list.csv;type=text/csv' \
    https://api.verifalia.com/v2.6/email-validations

var request = new FileValidationRequest("./my-list.csv")
{
    StartingRow = 2,
    Column = 1,
    Delimiter = ";"
};

// Submit the validation and wait for its completion

var validation = await verifalia
    .EmailValidations
    .SubmitAsync(request);

// Note: SubmitAsync() allows to specify the desired results quality and
// accepts arrays of email addresses as well: also, the method allows to
// configure the import operation as needed (see the section below for
// the details).

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

FileValidationRequest request = new FileValidationRequest("my-list.csv",
    WellKnownMimeTypes.TEXT_CSV);

request.setDelimiter(";"); // The default delimiter is comma (",")
request.setStartingRow(2);

Validation validation = verifalia
    .getEmailValidations()
    .submit(request);

// Initialize the request using the file to import

const file = fs.createReadStream('/my-list.csv');

// Submit the validation and wait for its completion

const result = await verifalia
    .emailValidations
    .submit({
        file: file,
        contentType: 'text/csv',
        startingRow: 2,
        delimiter: ';'
    });

// Note: submit() allows to specify the desired results quality and
// accepts arrays of email addresses as well: also, the method allows to
// configure the import operation as needed (see the section below for
// the details).

// The PHP SDK does not support importing files yet

# The Ruby SDK does not support importing files yet

curl -u username:password \
    --compressed \
    -F 'settings="{ \"quality\": \"High\", \"column\": 2, \"startingRow\": 1 }";type=application/json' \
    -F 'inputFile=@my-list.xls;type=application/vnd.ms-excel' \
    https://api.verifalia.com/v2.6/email-validations

var request = new FileValidationRequest("./sheet.xlsx")
{
    Column = 2,
    Sheet = 1
};

// Submit the validation and wait for its completion

var validation = await verifalia
    .EmailValidations
    .SubmitAsync(request);

// Note: SubmitAsync() allows to specify the desired results quality and
// accepts arrays of email addresses as well: also, the method allows to
// configure the import operation as needed (see the section below for
// the details).

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

FileValidationRequest request = new FileValidationRequest("my-list.xls",
    WellKnownMimeTypes.EXCEL_XLS);

request.setQuality(QualityLevelName.High);
request.setColumn(2);
request.setStartingRow(1);

Validation validation = verifalia
    .getEmailValidations()
    .submit(request);

// Import the MIME content type for Excel files (just a string, for our convenience)

import { MimeContentType_ExcelXlsx } from 'verifalia/node/esm/index.mjs';

// Initialize the request using the file to import

const file = fs.createReadStream('./sheet.xlsx');

// Submit the validation and wait for its completion

const result = await verifalia
    .emailValidations
    .submit({
        file: file,
        contentType: MimeContentType_ExcelXlsx,
        startingRow: 1,
        column: 2
    });

// Note: submit() allows to specify the desired results quality and
// accepts arrays of email addresses as well: also, the method allows to
// configure the import operation as needed (see the section below for
// the details).

// The PHP SDK does not support importing files yet

package main

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

func main() {
    client := verifalia.NewClient("<USERNAME>", "<PASSWORD>") // See above
	
    // Verifies an Excel file with a list of email addresses

    thatFile, err := os.Open("that-file.xslx")
	
    if err != nil {
        panic(err)
    }

    // Configure the validation options 

    options := emailValidation.SubmissionOptions{
        // High quality results
        Quality:   emailValidation.Quality.High,
        // One hour of data retention		
        Retention: 1 * time.Hour,
    }

    // Specify which data Verifalia should process through the file options 
	
    fileOptions := emailValidation.FileSubmissionOptions{
        // Second sheet
        Sheet:       1,
        // Ninth sheet      
        Column:      8,
        // Will start importing from the third row
        StartingRow: 2,
    }	

    validation, err = client.EmailValidation.RunFileWithOptions(thatFile,
        fileOptions,
        options,
        nil)

    if err != nil {
        panic(err)
    }

    // Print some results

    for _, entry := range validation.Entries {
        fmt.Printf("%v => %v\n",
            entry.EmailAddress,
            entry.Classification)
    }
}

# The Ruby SDK does not support importing files yet