One API call. Three checks.

require "net/http"
require "json"

class MailCopClient
  BASE_URL = "https://api.mailcop.net/v1"

  def initialize(api_key)
    @api_key = api_key
  end

  def verify_email(email, validation_type: "mx")
    uri = URI("#{BASE_URL}/verify")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true

    request = Net::HTTP::Post.new(uri)
    request["Authorization"] = "Bearer #{@api_key}"
    request["Content-Type"] = "application/json"
    request.body = { email: email, validation_type: validation_type }.to_json

    response = http.request(request)
    JSON.parse(response.body)
  end

  def usage
    uri = URI("#{BASE_URL}/usage")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true

    request = Net::HTTP::Get.new(uri)
    request["Authorization"] = "Bearer #{@api_key}"

    response = http.request(request)
    JSON.parse(response.body)
  end
end

# Usage
client = MailCopClient.new("YOUR_API_KEY")
result = client.verify_email("[email protected]")
puts result["status"] # => "good" or "bad"

import requests

class MailCopClient:
    BASE_URL = "https://api.mailcop.net/v1"

    def __init__(self, api_key):
        self.api_key = api_key
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }

    def verify_email(self, email, validation_type="mx"):
        response = requests.post(
            f"{self.BASE_URL}/verify",
            headers=self.headers,
            json={"email": email, "validation_type": validation_type}
        )
        return response.json()

    def usage(self):
        response = requests.get(
            f"{self.BASE_URL}/usage",
            headers=self.headers
        )
        return response.json()

# Usage
client = MailCopClient("YOUR_API_KEY")
result = client.verify_email("[email protected]")
print(result["status"])  # => "good" or "bad"

<?php

class MailCopClient {
    private $apiKey;
    private $baseUrl = "https://api.mailcop.net/v1";

    public function __construct($apiKey) {
        $this->apiKey = $apiKey;
    }

    public function verifyEmail($email, $validationType = "mx") {
        return $this->request("POST", "/verify", [
            "email" => $email,
            "validation_type" => $validationType
        ]);
    }

    public function usage() {
        return $this->request("GET", "/usage");
    }

    private function request($method, $path, $data = null) {
        $curl = curl_init();
        $url = $this->baseUrl . $path;

        curl_setopt_array($curl, [
            CURLOPT_URL => $url,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_CUSTOMREQUEST => $method,
            CURLOPT_HTTPHEADER => [
                "Authorization: Bearer " . $this->apiKey,
                "Content-Type: application/json"
            ]
        ]);

        if ($data) {
            curl_setopt($curl, CURLOPT_POSTFIELDS, json_encode($data));
        }

        $response = curl_exec($curl);
        curl_close($curl);

        return json_decode($response, true);
    }
}

// Usage
$client = new MailCopClient("YOUR_API_KEY");
$result = $client->verifyEmail("[email protected]");
echo $result["status"]; // => "good" or "bad"

class MailCopClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = "https://api.mailcop.net/v1";
  }

  async verifyEmail(email, validationType = "mx") {
    const response = await fetch(`${this.baseUrl}/verify`, {
      method: "POST",
      headers: {
        "Authorization": `Bearer ${this.apiKey}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({ email, validation_type: validationType })
    });
    return response.json();
  }

  async usage() {
    const response = await fetch(`${this.baseUrl}/usage`, {
      headers: {
        "Authorization": `Bearer ${this.apiKey}`
      }
    });
    return response.json();
  }
}

// Usage
const client = new MailCopClient("YOUR_API_KEY");
const result = await client.verifyEmail("[email protected]");
console.log(result.status); // => "good" or "bad"