require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.emailscore.io/v1/email')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

req = Net::HTTP::Post.new(uri.path, {
  'Authorization' => 'Bearer YOUR_API_KEY',
  'Content-Type' => 'application/json'
})
req.body = { email: '[email protected]' }.to_json

res = http.request(req)
data = JSON.parse(res.body)

puts "Score: #{data['score']}/100 | Decision: #{data['decision'].upcase}"
puts "Normalized: #{data.dig('identity', 'normalized_email')}"
puts "Fingerprint: #{data.dig('identity', 'fingerprint')}"
puts "Recommendation: #{data['recommendation']}"

if data['decision'] == 'deny'
  raise "Signup blocked: #{data['recommendation']}"
end

import requests

url = "https://api.emailscore.io/v1/email"
headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
}
payload = {"email": "[email protected]"}

response = requests.post(url, json=payload, headers=headers)
data = response.json()

print(f"Email: {data['email']}")
print(f"Score: {data['score']}/100 -> Decision: {data['decision'].upper()}")
print(f"Fingerprint: {data['identity']['fingerprint']}")
print(f"Recommendation: {data['recommendation']}")

// Single Email Check
const response = await fetch('https://api.emailscore.io/v1/email', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    email: '[email protected]'
  }),
});

const result = await response.json();
console.log(`Score: ${result.score}/100 | Decision: ${result.decision}`);
console.log('Normalized Identity:', result.identity.normalized_email);
console.log('Fingerprint:', result.identity.fingerprint);

package main

import (
    "bytes"
    "fmt"
    "io"
    "net/http"
)

func main() {
    url := "https://api.emailscore.io/v1/email"
    payload := []byte(`{"email": "[email protected]"}`)

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(payload))
    if err != nil {
        panic(err)
    }

    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

<?php
$ch = curl_init("https://api.emailscore.io/v1/email");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_API_KEY',
    'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'email' => '[email protected]'
]));

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

$result = json_decode($response, true);
echo "Score: " . $result['score'] . "/100 | Decision: " . strtoupper($result['decision']) . "\n";
echo "Fingerprint: " . $result['identity']['fingerprint'] . "\n";

use reqwest::header::{AUTHORIZATION, CONTENT_TYPE};
use serde_json::{json, Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let res = client
        .post("https://api.emailscore.io/v1/email")
        .header(AUTHORIZATION, "Bearer YOUR_API_KEY")
        .header(CONTENT_TYPE, "application/json")
        .json(&json!({ "email": "[email protected]" }))
        .send()
        .await?;

    let json: Value = res.json().await?;
    println!("Score: {} | Decision: {}", json["score"], json["decision"]);
    println!("Fingerprint: {}", json["identity"]["fingerprint"]);
    Ok(())
}

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.emailscore.io/v1/email/bulk')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

req = Net::HTTP::Post.new(uri.path, {
  'Authorization' => 'Bearer YOUR_API_KEY',
  'Content-Type' => 'application/json',
  'Accept-Encoding' => 'gzip'
})
req.body = {
  emails: [
    '[email protected]',
    '[email protected]',
    '[email protected]'
  ]
}.to_json

res = http.request(req)
batch = JSON.parse(res.body)

puts "Verified #{batch['processed']}/#{batch['total']} in #{batch['evaluation_time_ms']}ms"
puts "Summary: Allow=#{batch.dig('summary', 'allow')}, Deny=#{batch.dig('summary', 'deny')}"

batch['results'].each do |item|
  puts "  [#{item['decision'].upcase}] #{item['email']} -> Score: #{item['score']}"
end

import requests

url = "https://api.emailscore.io/v1/email/bulk"
headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
    "Accept-Encoding": "gzip",
}
payload = {
    "emails": [
        "[email protected]",
        "[email protected]",
        "[email protected]",
    ]
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()

print(f"Total: {data['total']} | Evaluation Time: {data['evaluation_time_ms']}ms")
print(f"Summary: Allow={data['summary']['allow']}, Deny={data['summary']['deny']}")
for item in data['results']:
    print(f" - {item['email']}: {item['score']} ({item['decision']})")

// Bulk / Batch Email Check (Up to 10,000 emails in parallel)
const response = await fetch('https://api.emailscore.io/v1/email/bulk', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    'Accept-Encoding': 'gzip',
  },
  body: JSON.stringify({
    emails: [
      '[email protected]',
      '[email protected]',
      '[email protected]',
    ]
  }),
});

const batch = await response.json();
console.log(`Verified ${batch.processed}/${batch.total} in ${batch.evaluation_time_ms}ms`);
console.log('Summary:', batch.summary); // { allow: 2, challenge: 0, deny: 1 }

package main

import (
    "bytes"
    "fmt"
    "io"
    "net/http"
)

func main() {
    url := "https://api.emailscore.io/v1/email/bulk"
    payload := []byte(`{"emails": ["[email protected]", "[email protected]", "[email protected]"]}`)

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(payload))
    if err != nil {
        panic(err)
    }

    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Accept-Encoding", "gzip")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

<?php
$ch = curl_init("https://api.emailscore.io/v1/email/bulk");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_ENCODING, "gzip");
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_API_KEY',
    'Content-Type: application/json',
    'Accept-Encoding: gzip'
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'emails' => [
        '[email protected]',
        '[email protected]',
        '[email protected]'
    ]
]));

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

$batch = json_decode($response, true);
echo "Verified " . $batch['processed'] . "/" . $batch['total'] . " in " . $batch['evaluation_time_ms'] . "ms\n";

use reqwest::header::{ACCEPT_ENCODING, AUTHORIZATION, CONTENT_TYPE};
use serde_json::{json, Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let res = client
        .post("https://api.emailscore.io/v1/email/bulk")
        .header(AUTHORIZATION, "Bearer YOUR_API_KEY")
        .header(CONTENT_TYPE, "application/json")
        .header(ACCEPT_ENCODING, "gzip")
        .json(&json!({
            "emails": [
                "[email protected]",
                "[email protected]",
                "[email protected]"
            ]
        }))
        .send()
        .await?;

    let batch: Value = res.json().await?;
    println!("Processed: {}/{}", batch["processed"], batch["total"]);
    println!("Summary: {}", batch["summary"]);
    Ok(())
}

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.emailscore.io/v1/domain')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

req = Net::HTTP::Post.new(uri.path, {
  'Authorization' => 'Bearer YOUR_API_KEY',
  'Content-Type' => 'application/json'
})
req.body = { domain: 'acme.com' }.to_json

res = http.request(req)
data = JSON.parse(res.body)

puts "Score: #{data['score']}/100 | Decision: #{data['decision'].upcase}"
puts "Evidence: #{data['evidence']} | Flags: #{data['flags'].join(', ')}"
puts "Recommendation: #{data['recommendation']}"

import requests

url = "https://api.emailscore.io/v1/domain"
headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
}
payload = {"domain": "acme.com"}

response = requests.post(url, json=payload, headers=headers)
data = response.json()

print(f"Domain: {data['domain']}")
print(f"Score: {data['score']}/100 -> Decision: {data['decision'].upper()}")
print(f"Evidence: {data['evidence']} | Flags: {data['flags']}")
print(f"Recommendation: {data['recommendation']}")

// Domain Check
const response = await fetch('https://api.emailscore.io/v1/domain', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    domain: 'acme.com'
  }),
});

const result = await response.json();
console.log(`Score: ${result.score}/100 | Decision: ${result.decision}`);
console.log('Evidence:', result.evidence, '| Flags:', result.flags);

package main

import (
    "bytes"
    "fmt"
    "io"
    "net/http"
)

func main() {
    url := "https://api.emailscore.io/v1/domain"
    payload := []byte(`{"domain": "acme.com"}`)

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(payload))
    if err != nil {
        panic(err)
    }

    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

<?php
$ch = curl_init("https://api.emailscore.io/v1/domain");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_API_KEY',
    'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'domain' => 'acme.com'
]));

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

$result = json_decode($response, true);
echo "Score: " . $result['score'] . "/100 | Decision: " . strtoupper($result['decision']) . "\n";
echo "Evidence: " . $result['evidence'] . "\n";

use reqwest::header::{AUTHORIZATION, CONTENT_TYPE};
use serde_json::{json, Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let res = client
        .post("https://api.emailscore.io/v1/domain")
        .header(AUTHORIZATION, "Bearer YOUR_API_KEY")
        .header(CONTENT_TYPE, "application/json")
        .json(&json!({ "domain": "acme.com" }))
        .send()
        .await?;

    let json: Value = res.json().await?;
    println!("Score: {} | Decision: {}", json["score"], json["decision"]);
    println!("Evidence: {} | Flags: {}", json["evidence"], json["flags"]);
    Ok(())
}

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.emailscore.io/v1/domain/bulk')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

req = Net::HTTP::Post.new(uri.path, {
  'Authorization' => 'Bearer YOUR_API_KEY',
  'Content-Type' => 'application/json',
  'Accept-Encoding' => 'gzip'
})
req.body = {
  domains: [
    'google.com',
    'gmial.com',
    'not a domain'
  ]
}.to_json

res = http.request(req)
batch = JSON.parse(res.body)

puts "Scored #{batch['processed']}/#{batch['total']} in #{batch['evaluation_time_ms']}ms"
puts "Summary: Allow=#{batch.dig('summary', 'allow')}, Deny=#{batch.dig('summary', 'deny')}"

batch['results'].each do |item|
  puts "  [#{item['decision'].upcase}] #{item['domain']} -> Score: #{item['score']} #{item['flags'].join(',')}"
end

import requests

url = "https://api.emailscore.io/v1/domain/bulk"
headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
    "Accept-Encoding": "gzip",
}
payload = {
    "domains": [
        "google.com",
        "gmial.com",
        "not a domain",
    ]
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()

print(f"Total: {data['total']} | Evaluation Time: {data['evaluation_time_ms']}ms")
print(f"Summary: Allow={data['summary']['allow']}, Deny={data['summary']['deny']}")
for item in data['results']:
    print(f" - {item['domain']}: {item['score']} ({item['decision']}) {item['flags']}")

// Bulk / Batch Domain Check (up to 10,000 domains per request)
const response = await fetch('https://api.emailscore.io/v1/domain/bulk', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    'Accept-Encoding': 'gzip',
  },
  body: JSON.stringify({
    domains: [
      'google.com',
      'gmial.com',
      'not a domain',
    ]
  }),
});

const batch = await response.json();
console.log(`Scored ${batch.processed}/${batch.total} in ${batch.evaluation_time_ms}ms`);
console.log('Summary:', batch.summary); // { allow: 1, challenge: 0, deny: 2 }

package main

import (
    "bytes"
    "fmt"
    "io"
    "net/http"
)

func main() {
    url := "https://api.emailscore.io/v1/domain/bulk"
    payload := []byte(`{"domains": ["google.com", "gmial.com", "not a domain"]}`)

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(payload))
    if err != nil {
        panic(err)
    }

    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Accept-Encoding", "gzip")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

<?php
$ch = curl_init("https://api.emailscore.io/v1/domain/bulk");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_ENCODING, "gzip");
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_API_KEY',
    'Content-Type: application/json',
    'Accept-Encoding: gzip'
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'domains' => [
        'google.com',
        'gmial.com',
        'not a domain'
    ]
]));

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

$batch = json_decode($response, true);
echo "Scored " . $batch['processed'] . "/" . $batch['total'] . " in " . $batch['evaluation_time_ms'] . "ms\n";

use reqwest::header::{ACCEPT_ENCODING, AUTHORIZATION, CONTENT_TYPE};
use serde_json::{json, Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let res = client
        .post("https://api.emailscore.io/v1/domain/bulk")
        .header(AUTHORIZATION, "Bearer YOUR_API_KEY")
        .header(CONTENT_TYPE, "application/json")
        .header(ACCEPT_ENCODING, "gzip")
        .json(&json!({
            "domains": [
                "google.com",
                "gmial.com",
                "not a domain"
            ]
        }))
        .send()
        .await?;

    let batch: Value = res.json().await?;
    println!("Processed: {}/{}", batch["processed"], batch["total"]);
    println!("Summary: {}", batch["summary"]);
    Ok(())
}

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.emailscore.io/v1/bounce/diagnose')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

req = Net::HTTP::Post.new(uri.path, {
  'Authorization' => 'Bearer YOUR_API_KEY',
  'Content-Type' => 'application/json'
})
req.body = {
  diagnostic: '550 5.1.1 <[email protected]>: Recipient address rejected: User unknown in virtual mailbox table',
  email: '[email protected]'
}.to_json

res = http.request(req)
triage = JSON.parse(res.body)

puts "Action: #{triage['action']} | Category: #{triage['category']}"
puts "Hard Bounce Probability: #{(triage['permanent_hard_bounce_probability'] * 100).round}%"
puts "Recommendation: #{triage['recommendation']}"

if triage['action'] == 'prune_permanent'
  # Mailbox does not exist: purge from recipient list
  puts "Purging dead address: #{triage['email']}"
else
  # Temporary failure (quota/greylist): safe to retry
  puts "Transient bounce: queuing retry for #{triage['email']}"
end

import requests

url = "https://api.emailscore.io/v1/bounce/diagnose"
headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
}
payload = {
    "diagnostic": "550 5.1.1 <[email protected]>: Recipient address rejected: User unknown in virtual mailbox table",
    "email": "[email protected]",
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()

print(f"Action: {data['action'].upper()} -> Category: {data['category']}")
print(f"Probability: {data['permanent_hard_bounce_probability'] * 100:.0f}%")
print(f"Recommendation: {data['recommendation']}")

if data["action"] == "prune_permanent":
    suppress_contact(data.get("email"))
else:
    schedule_retry(data.get("email"))

// Post-Flight SMTP Bounce Triage (5 credits)
const response = await fetch('https://api.emailscore.io/v1/bounce/diagnose', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    diagnostic: '550 5.1.1 <[email protected]>: Recipient address rejected: User unknown',
    email: '[email protected]',
  }),
});

const triage = await response.json();
console.log(`Action: ${triage.action} | Category: ${triage.category}`);
console.log(`Hard Bounce Probability: ${(triage.permanent_hard_bounce_probability * 100).toFixed(0)}%`);

if (triage.action === 'prune_permanent') {
  // Purge dead mailbox from mailing list
  await suppressContact(triage.email);
} else {
  // Safe to retry transient failure
  await scheduleRetry(triage.email);
}

package main

import (
    "bytes"
    "fmt"
    "io"
    "net/http"
)

func main() {
    url := "https://api.emailscore.io/v1/bounce/diagnose"
    payload := []byte(`{
        "diagnostic": "550 5.1.1 <[email protected]>: Recipient address rejected: User unknown",
        "email": "[email protected]"
    }`)

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(payload))
    if err != nil {
        panic(err)
    }

    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

<?php
$ch = curl_init("https://api.emailscore.io/v1/bounce/diagnose");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_API_KEY',
    'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'diagnostic' => '550 5.1.1 <[email protected]>: Recipient address rejected: User unknown in virtual mailbox table',
    'email' => '[email protected]'
]));

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

$triage = json_decode($response, true);
echo "Action: " . $triage['action'] . " | Category: " . $triage['category'] . "\n";
if ($triage['action'] === 'prune_permanent') {
    suppress_contact($triage['email']);
}

use reqwest::header::{AUTHORIZATION, CONTENT_TYPE};
use serde_json::{json, Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let res = client
        .post("https://api.emailscore.io/v1/bounce/diagnose")
        .header(AUTHORIZATION, "Bearer YOUR_API_KEY")
        .header(CONTENT_TYPE, "application/json")
        .json(&json!({
            "diagnostic": "550 5.1.1 <[email protected]>: Recipient address rejected: User unknown",
            "email": "[email protected]"
        }))
        .send()
        .await?;

    let json: Value = res.json().await?;
    println!("Action: {} | Category: {}", json["action"], json["category"]);
    println!("Recommendation: {}", json["recommendation"]);
    Ok(())
}