curl --request GET\
  --url 'https://api.neverbounce.com/v4/account/info?key={api_key}'

<?php

// Set API key
\NeverBounce\Auth::setApiKey($api_key);

// Make request for API info
$info = \NeverBounce\Account::info();

// Initialize NeverBounce client
const client = new NeverBounce({apiKey: myApiKey});

// Get account info
client.account.info().then(
    resp => // Handle successful response
    err => // Handle error response
);

import neverbounce_sdk

# Create sdk client
client = neverbounce_sdk.client(api_key='api_key')

# Get account info
info = client.account_info();

// Instantiate wrapper
client := neverbounce.New("api_key")

// Get account info
accountInfo, err := client.Account.Info()

# Instantiate API client
client = NeverBounce::API::Client.new(api_key: "api_key")

# Get account info
resp = client.account_info

// Create SDK object
var sdk = new NeverBounceSdk("api_key");

// Get account info
AccountInfoResponseModel resp = sdk.Account.Info().Result;

// Instantiate Client
NeverbounceClient neverbounceClient = NeverbounceClientFactory.create(apiKey);

// Make Request
AccountInfoResponse accountInfoResponse = neverbounceClient.createAccountInfoRequest().execute();

# Be sure to encode email before making the request (@ becomes %40)
curl --request GET\
  --url 'https://api.neverbounce.com/v4/single/check?key={api_key}&email={email}'

<?php

// Set API key
\NeverBounce\Auth::setApiKey($api_key);

// Make verification request, specify optional $max_execution_time
$result = \NeverBounce\Single::check(
  'support@neverbounce.com', // Email to verify
  true, // Address info
  true, // Credits info
  10 // Timeout in seconds
);

// Initialize NeverBounce client
const client = new NeverBounce({apiKey: myApiKey});

/// Verify an email
client.single.check(
  'support@neverbounce.com', 
  true, // Address info
  true // Credits info
  10 // timeout
).then(
    result => // Handle success response
    err => // Handle error response
);

import neverbounce_sdk

# Create sdk client
client = neverbounce_sdk.client(api_key='api_key')

# Verify email
verification = client.single_check(
  email='support@neverbounce.com',
  address_info=True,
  credits_info=True,
  timeout=10  # Timeout in seconds
)

// Instantiate wrapper
client := neverbounce.New("api_key")

// Verify an email
singleResults, err := client.Single.Check(&nbModels.SingleCheckRequestModel{
  Email:       "support@neverbounce.com",
  AddressInfo: true,
  CreditInfo:  true,
  Timeout:     10,
})

# Instantiate API client
client = NeverBounce::API::Client.new(api_key: "api_key")

# Get account info
resp = client.single_check(
  email: "support@neverbounce.com", 
  address_info: true, 
  credits_info: true, 
  timeout: 10)

// Create SDK object
var sdk = new NeverBounceSdk("api_key");

// Create request model
var model = new SingleRequestModel();
model.email = "support@neverbounce.com";
model.credits_info = true;
model.address_info = true;
model.timeout = 10; 

// Verify single email
SingleResponseModel resp = sdk.Single.Check(model).Result;

// Instantiate Client
NeverbounceClient neverbounceClient = NeverbounceClientFactory.create(apiKey);

// Perform verification
SingleCheckResponse singleCheckResponse = neverbounceClient
            .prepareSingleCheckRequest()
            .withEmail("support@neverbounce.com")
            .withAddressInfo(true)
            .withCreditsInfo(true)
            .withTimeout(10)
            .build()
            .execute()

curl --request GET\
  --url 'https://api.neverbounce.com/v4/jobs/search?key={api_key}'

<?php

// Set API key
\NeverBounce\Auth::setApiKey($api_key);

$query = [
//    'job_id' => 10000, // Filter jobs based on id
//    'filename' => 'Book1.csv', // Filter jobs based on filename
//    'job_status' => 'complete', // Show completed jobs only
//    'page' => 1, // Page to start from
//    'items_per_page' => 10, // Number of items per page
];

// Search for jobs in your account
$job = \NeverBounce\Jobs::search($query);

// Initialize NeverBounce client
const client = new NeverBounce({apiKey: myApiKey});

// Search jobs
client.jobs.search({
//    'job_id': 10000, // Filter jobs based on id
//    'filename': 'Book1.csv', // Filter jobs based on filename
//    'job_status': 'complete', // Show completed jobs only
//    'page': 1, // Page to start from
//    'items_per_page': 10, // Number of items per page
}).then(
    resp => // Handle successful response,
    err => // Handle error response
););

import neverbounce_sdk

# Create sdk client
client = neverbounce_sdk.client(api_key='api_key)

# Get jobs
jobs = client.jobs_search(
    # job_id=10000,  # Filter jobs based on id
    # filename='Book1.csv',  # Filter jobs based on filename
    # job_status='complete',  # Show completed jobs only
    # page=1,  # Page to start from
    # items_per_page=10,  # Number of items per page
)

# iterate through jobs
for job in jobs:
    print(job)

// Instantiate wrapper
client := neverbounce.New("api_key")

// Search for jobs
searchResults, err := client.Jobs.Search(&nbModels.JobsSearchRequestModel{
  //JobFilename: "MyListName.csv",
  //JobID: 289010,
  //JobStatus: "complete",
  //ItemsPerPage: 10,
  //Page: 1,
})

# Instantiate API client
client = NeverBounce::API::Client.new(api_key: "api_key")

# Search for jobs
resp = client.jobs_search(page: 1, per_page: 10)

# Process items:
resp.results.each do |item|

// Create SDK object
var sdk = new NeverBounceSdk("api_key");

// Create search model
var model = new JobSearchRequestModel();
//model.job_id = 288025;
//model.job_status = "complete";
//model.filename = "MyFile.csv";
//model.items_per_page = 10;
//model.page = 1;

// Get jobs
JobSearchResponseModel resp = sdk.Jobs.Search(model).Result;

// Instantiate Client
NeverbounceClient neverbounceClient = NeverbounceClientFactory.create(apiKey);

// Search for jobs
JobsSearchResponse jobsSearchResponse = neverbounceClient
        .prepareJobsSearchRequest()
        .withJobId(jobId)
        .build()
        .execute();

# x-www-form-urlencoded request w/ remote_url input
curl --request POST\
  --url https://api.neverbounce.com/v4/jobs/create\
  --data key={api_key}\
  --data input_location='remote_url'\
  --data filename='SampleNeverBounceAPI.csv'\
  --data auto_parse=true\
  --data auto_start=true\
  --data input='https://mydomain.com/my_file.csv'

# x-www-form-urlencoded request w/ supplied data
curl --request POST\
  --url https://api.neverbounce.com/v4/jobs/create\
  --data key={api_key}\
  --data input_location='supplied'\
  --data filename='SampleNeverBounceAPI.csv'\
  --data auto_parse=true\
  --data auto_start=true\
  --data 'input[0][0]=support%40neverbounce.com'\
  --data 'input[0][1]=Fred%20McValid'\
  --data 'input[1][0]=invalid%40neverbounce.com'\
  --data 'input[1][1]=Bob%20McInvalid'
  
# JSON encoded request w/ supplied data
curl --request POST\
  --header "Content-Type: application/json"\
  --url https://api.neverbounce.com/v4/jobs/create\
  --data '{
    "key": {api_key},
    "input_location": "supplied",
    "filename": "SampleNeverBounceAPI.csv",
    "auto_start": true,
    "auto_parse": true,
    "input": [
        [
            "support@neverbounce.com",
            "Fred McValid"
        ],
        [
            "invalid@neverbounce.com",
            "Bob McInvalid"
        ]
    ]
}'

<?php

// Set API key
\NeverBounce\Auth::setApiKey($api_key);

// Build json
$arr = [
    [
        'support@neverbounce.com',
        'Fred McValid'
    ],
    [
        'invalid@neverbounce.com',
        'Bob McInvalid'
    ]
];

// Make a new job with the supplied data
$job = \NeverBounce\Jobs::create(
  $arr, // input
  \NeverBounce\Jobs::SUPPLIED_INPUT, // Either `supplied` or `remote_url`
  'SampleNeverBounceAPI.csv', // Friendly name that can be used to identify job
  false, // Run as sample
  true, // Auto parse
  true, // Auto start
);

// Initialize NeverBounce client
const client = new NeverBounce({apiKey: myApiKey});

// Verify a list of emails
client.jobs.create(
    [
        {
            'id': '12345',
            'email': 'support@neverbounce.com',
            'name': 'Fred McValid'
        },
        {
            'id': '12346',
            'email': 'invalid@neverbounce.com',
            'name': 'Bob McInvalid'
        }
    ],
    'supplied', // Either `supplied` or `remote_url`
    'Created from Array.csv', // Friendly name that can be used to identify job
  	false, // Run sample
  	true, // Auto parse
    true // Auto run
).then(
    resp => // Handle success response
    err => // Handle error response
);

import neverbounce_sdk

# Create sdk client
client = neverbounce_sdk.client(api_key='api_key')

# Create array of data
inputData = [
  {
    'id': '12345',
    'email': 'support@neverbounce.com',
    'name': 'Fred McValid'
  },
  {
    'id': '12346',
    'email': 'invalid@neverbounce.com',
    'name': 'Bob McInvalid'
  }
]

# Create Job
resp = client.jobs_create(
  input=inputData,
  filename="Created from Python Wrapper.csv",
  # auto_parse=True,
  # auto_start=True,
  # as_sample=False,
  # from_url=False
)

// Instantiate wrapper
client := neverbounce.New("api_key")

// Build data map
createData := map[int]interface{}{}
createData[0] = map[string]interface{}{
  "id":    12345,
  "email": "support@neverbounce.com",
  "name":  "Bob McValid",
}
createData[1] = map[string]interface{}{
  "id":    12346,
  "email": "invalid@neverbounce.com",
  "name":  "Fred McInvalid",
}

// Create a job from supplied data
jobInfo, err := client.Jobs.CreateFromSuppliedData(&nbModels.JobsCreateSuppliedDataRequestModel{
  SuppliedData: createData,
  AutoParse:    false,
  AutoRun:      false,
  RunSample:    false,
  FileName:     "Created from Golang.csv",
})
if err != nil {
  panic(err)
}

// Create a job from a remote URL
jobInfo, err := client.Jobs.CreateFromRemoteURL(&nbModels.JobsCreateRemoteURLRequestModel{
  RemoteURL: "https://example.com/file.csv",
  AutoParse: true,
  AutoRun:   false,
  RunSample: false,
  FileName:  "Created from Golang.csv",
})
if err != nil {
  panic(err)
}

# Instantiate API client
client = NeverBounce::API::Client.new(api_key: "api_key")

# Create job with supplied input
resp = client.jobs_create(supplied_input: [["alice@isp.com", "Alice Roberts"], ["bob.smith@gmail.com", "Bob Smith"]])

# Create job with remote file
resp = client.jobs_create(remote_input: "http://example.com/emails.csv", filename: "emails.csv", run_sample: true)

// Create SDK object
var sdk = new NeverBounceSdk("api_key");

/**
 * Create a job using supplied data
 */

// Create supplied data model
var model = new JobCreateSuppliedDataRequestModel();
model.filename = "Created From dotNET.csv";
model.auto_parse = true;
model.auto_start = false;
model.input = new List<object>();
model.input.Add(new {id = "3", email = "support@neverbounce.com", name = "Fred McValid"});
model.input.Add(new {id = "4", email = "invalid@neverbounce.com", name = "Bob McInvalid"});

// Create job from supplied data
JobCreateResponseModel resp = sdk.Jobs.CreateFromSuppliedData(model).Result;

/**
 * Create a job using a remote url
 */

// Create remote url model
var model2 = new JobCreateRemoteUrlRequestModel();
model.filename = "Created From dotNET.csv";
model.auto_parse = true;
model.auto_start = false;
model.input = "https://example.com/file.csv";

// Create job from remote url
JobCreateResponseModel resp2 = sdk.Jobs.CreateFromRemoteUrl(model).Result;

curl --request POST\
  --url https://api.neverbounce.com/v4/jobs/parse\
  --data key={api_key}\
  --data job_id={job_id}

<?php

// Set API key
\NeverBounce\Auth::setApiKey($api_key);

// Make a new job with the supplied data
$job = \NeverBounce\Jobs::parse(
  $job_id,
  //false // Auto start
);

// Initialize NeverBounce client
const client = new NeverBounce({apiKey: myApiKey});

// Parse a job
client.jobs.parse(
  jobId,
  //false // Auto start
).then(
    resp => // Handle success response
    err => // Handle error response
);

import neverbounce_sdk

# Create sdk client
client = neverbounce_sdk.client(api_key='api_key')

# Parse job
resp = client.jobs_parse(
  job_id=289022,
  #auto_start=False
)

// Instantiate wrapper
client := neverbounce.New("api_key")

// Parse a job
parseInfo, err := client.Jobs.Parse(&nbModels.JobsParseRequestModel{
  JobID: 296050,
//  AutoStart: false,
})

# Instantiate API client
client = NeverBounce::API::Client.new(api_key: "api_key")

# Parse job
resp = client.jobs_parse(job_id: 123)

// Create SDK object
var sdk = new NeverBounceSdk("api_key");

// Create parse job model
var model = new JobParseRequestModel();
model.job_id = 290561;
//model.auto_start = false;

// Parse job
JobParseResponseModel resp sdk.Jobs.Parse(model).Result;

curl --request POST\
  --url https://api.neverbounce.com/v4/jobs/start\
  --data key={api_key}\
  --data job_id={job_id}

<?php

// Set API key
\NeverBounce\Auth::setApiKey($api_key);

// Start a job that has been parsed
$job = \NeverBounce\Jobs::start($job_id);

// Initialize NeverBounce client
const client = new NeverBounce({apiKey: myApiKey});

// Start a job
client.jobs.start(jobId).then(
    resp => // Handle successful response
    err => // Handle error response
);

import neverbounce_sdk

# Create sdk client
client = neverbounce_sdk.client(api_key='api_key')

# Start job
resp = client.jobs_start(job_id=289022)

// Instantiate wrapper
client = neverbounce.New("api_key")

// Start a job
startInfo, err := client.Jobs.Start(&nbModels.JobsStartRequestModel{
  JobID: 296050,
//  RunSample: false,
})

# Instantiate API client
client = NeverBounce::API::Client.new(api_key: "api_key")

# Start a job
resp = client.client.jobs_start(job_id: 123)

// Create SDK object
var sdk = new NeverBounceSdk("api_key");

// Create start job model
var model = new JobStartRequestModel();
model.job_id = 290561;
//model.run_sample = true;

// Start job
JobStartResponseModel resp = sdk.Jobs.Start(model).Result;

curl --request GET\
  --url 'https://api.neverbounce.com/v4/jobs/status?key={api_key}&job_id={job_id}'

<?php

// Set API key
\NeverBounce\Auth::setApiKey($api_key);

// Get the details about the job
$job = \NeverBounce\Jobs::status($job_id);

// Initialize NeverBounce client
const client = new NeverBounce({apiKey: myApiKey});

// Get the job status
client.jobs.status(jobId).then(
    resp => // Handle successful response,
    err => // Handle error response
);

import neverbounce_sdk

# Create sdk client
client = neverbounce_sdk.client(api_key='api_key')

# Get job status
resp = client.jobs_status(job_id=289022)

// Instantiate wrapper
client := neverbounce.New("api_key")

// Query a job's status
statusInfo, err := client.Jobs.Status(&nbModels.JobsStatusRequestModel{
  JobID: 296050,
})

# Instantiate API client
client = NeverBounce::API::Client.new(api_key: "api_key")

# Parse job
resp = client.jobs_status(job_id: 123)

// Create SDK object
var sdk = new NeverBounceSdk("api_key");

// Create job status model
var model = new JobStatusRequestModel();
model.job_id = 290561;

// Query job status
JobStatusResponseModel resp = sdk.Jobs.Status(model).Result;

curl --request GET\
  --url 'https://api.neverbounce.com/v4/jobs/results?key={api_key}&job_id={job_id}'

<?php

// Set API key
\NeverBounce\Auth::setApiKey($api_key);

$query = [
  //'items_per_page' => 10,
  //'page' => 1,
];

// Get the results from the job
$job = \NeverBounce\Jobs::results($job_id, $query);

// Initialize NeverBounce client
const client = new NeverBounce({apiKey: myApiKey});

// Get the job results
client.jobs.results(jobId, {
//    'page': 1, // Page to start from
//    'items_per_page': 10, // Number of items per page
}).then(
    resp => // Handle successful response,
    err => // Handle error response
);

import neverbounce_sdk

# Create sdk client
client = neverbounce_sdk.client(api_key='api_key')

# Get job's results
jobs = client.jobs_results(
    job_id=289022
    # page=1,  # Page to start from
    # items_per_page=10,  # Number of items per page
)

# Iterate through jobs
for job in jobs:
    print(job)

// Instantiate wrapper
client := neverbounce.New("api_key")

// Get the results for a job
resultsInfo, err := client.Jobs.Results(&nbModels.JobsResultsRequestModel{
  JobID: 296050,
  //ItemsPerPage: 10,
  //Page: 1,
})

# Instantiate API client
client = NeverBounce::API::Client.new(api_key: "api_key")

# Download job results
resp = client.jobs_results(job_id: 123, page: 1, per_page: 20)

# Process items:
resp.results.items.each do |item| ...

// Create SDK object
var sdk = new NeverBounceSdk("api_key");

// Create job results model
var model = new JobResultsRequestModel();
model.job_id = 290561;
//model.items_per_page = 10;
//model.page = 1;

// Get job's results
JobResultsResponseModel resp = sdk.Jobs.Results(model).Result;

curl --request POST\
  --url https://api.neverbounce.com/v4/jobs/delete\
  --data key={api_key}\
  --data job_id={job_id}

<?php

// Set API key
\NeverBounce\Auth::setApiKey($api_key);

// Delete a job
$job = \NeverBounce\Jobs::delete($job_id);

// Initialize NeverBounce client
const client = new NeverBounce({apiKey: myApiKey});

// Delete the job
client.jobs.delete(jobId).then(
    resp => // Handle successful response,
    err => // Handle errors
);

import neverbounce_sdk

# Create sdk client
client = neverbounce_sdk.client(api_key='api_key')

# Delete job
resp = client.jobs_delete(job_id=289022)

// Instantiate wrapper
client := neverbounce.New("api_key")

// Delete a job
deleteInfo, err := client.Jobs.Delete(&nbModels.JobsDeleteRequestModel{
  JobID: 296050,
})

# Instantiate API client
client = NeverBounce::API::Client.new(api_key: "api_key")

# Delete job
resp = client.jobs_delete(job_id: 123)

// Create SDK object
var sdk = new NeverBounceSdk("api_key");

// Create job delete model
var model = new JobDeleteRequestModel();
model.job_id = 290561;

// Delete job
JobDeleteRequestModel resp = sdk.Jobs.Delete(model).Result;

curl --request POST\
  --url https://api.neverbounce.com/v4/poe/confirm\
  --data key={api_key}\
  --data email={email}\
  --data transaction_id={transaction_id}\
  --data confirmation_token={confirmation_token}
  --data result={result}

<?php

// Authenticate requests
\NeverBounce\Auth::setApiKey($api_key);

// Confirm submission
$poe = \NeverBounce\PoE::confirm(
  $_POST['email'], 
  $_POST['nb-confirmation-token'], 
  $_POST['nb-transaction-id'], 
  $_POST['nb-result']
);

// Initialize NeverBounce client
const client = new NeverBounce({apiKey: myApiKey});

// Get the job status
client.jobs.poe(
  req.body['email'], 
  req.body['nb-confirmation-token'], 
  req.body['nb-transaction-id'], 
  req.body['nb-result']
).then(
    resp => // Handle successful response,
    err => // Handle errors
);

# Create sdk client
client = neverbounce_sdk.client(api_key='api_key')

# Confirm frontend widget
resp = client.poe_confirm(
    email='support@neverbounce.com',
    transaction_id='NBPOE-TXN-5942940c09669',
    confirmation_token='e3173fdbbdce6bad26522dae792911f2',
    result='valid'
)

// Instantiate wrapper
client := neverbounce.New("api_key")

// Confirm the client side verification
confirmInfo, err := client.POE.Confirm(&nbModels.POEConfirmRequestModel{
  Email:             "support@neverbounce.com",
  ConfirmationToken: "1341234jkh12h34lb2134b143",
  TransactionID:     "1340813265013984123",
  Result:            "valid",
})

# Instantiate API client
client = NeverBounce::API::Client.new(api_key: "api_key")

# Confirm verification
resp = client.poe_confirm(
  email: "alice@isp.com", 
  transaction_id: "NBTRNS-abcdefg123456", 
  confirmation_token: "abcdefg123456", 
  result: "valid"
)

// Create SDK object
var sdk = new NeverBounceSdk("api_key");

// Create poe confirm model
 var model = new POEConfirmRequestModel();
model.email = "support@neverbounce.com";
model.confirmation_token = "e3173fdbbdce6bad26522dae792911f2";
model.transaction_id = "NBPOE-TXN-5942940c09669";
model.result = "valid";

// Confirm frontend verification
POEConfirmResponseModel resp = sdk.POE.Confirm(model).Result;