Quick Start

Prerequisites

Before you begin, you’ll need:

• A Spamidate account (sign up for free)
• Your API key (created after you complete your subscription)

Step 1: Get Your API Keys

1. Sign up at spamidate.com/signup
2. Choose your plan and complete payment
3. Access your dashboard and create an API key
4. Save both keys immediately:
   • Secret Key (sk_live_...) - For server-side calls (shown ONCE)
   • Publishable Key (pk_live_...) - For client-side use (always visible)

Secret keys are shown ONCE

Secret keys cannot be retrieved after creation. Save your sk_live_... key immediately in a secure location (environment variables, secret manager, etc.).

Step 2: Make Your First Request

Choose your preferred language:

cURL

Validate an email

curl -X POST https://api.spamidate.com/validate \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "user@example.com"}'

JavaScript

validate.js

const response = await fetch('https://api.spamidate.com/validate', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ email: 'user@example.com' })
});

const result = await response.json();
console.log(result.isValid); // true or false

Python

validate.py

import requests

response = requests.post(
    'https://api.spamidate.com/validate',
    headers={'X-API-Key': 'YOUR_API_KEY'},
    json={'email': 'user@example.com'}
)

result = response.json()
print(result['isValid'])  # True or False

PHP

validate.php

<?php
$ch = curl_init('https://api.spamidate.com/validate');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'X-API-Key: YOUR_API_KEY',
    'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'email' => 'user@example.com'
]));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$result = json_decode($response, true);
echo $result['isValid'] ? 'Valid' : 'Invalid';

Ruby

validate.rb

require 'net/http'
require 'json'

uri = URI('https://api.spamidate.com/validate')
request = Net::HTTP::Post.new(uri)
request['X-API-Key'] = 'YOUR_API_KEY'
request['Content-Type'] = 'application/json'
request.body = { email: 'user@example.com' }.to_json

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

result = JSON.parse(response.body)
puts result['isValid'] ? 'Valid' : 'Invalid'

Go

validate.go

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

type ValidationRequest struct {
    Email string `json:"email"`
}

type ValidationResponse struct {
    IsValid bool `json:"isValid"`
}

func main() {
    payload := ValidationRequest{Email: "user@example.com"}
    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", "https://api.spamidate.com/validate", bytes.NewBuffer(jsonData))
    req.Header.Set("X-API-Key", "YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    var result ValidationResponse
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Println(result.IsValid)
}

Step 3: Handle the Response

A successful validation returns a JSON object with detailed information:

Success Response

{
  "isValid": true,
  "email": "user@example.com",
  "score": 95,
  "severity": "valid",
  "checks": {
    "syntax": {
      "passed": true,
      "message": "Valid email format"
    },
    "domain": {
      "passed": true,
      "message": "Domain exists and has MX records"
    },
    "disposable": {
      "passed": true,
      "message": "Not a disposable email"
    },
    "smtp": {
      "passed": true,
      "message": "Mailbox exists and can receive email"
    }
  },
  "recommendations": ["Email is valid and safe to use"],
  "metadata": {
    "processingTime": 45,
    "timestamp": "2025-01-15T10:30:00Z"
  }
}

Response Fields

• isValid (boolean): Overall validation result
• score (number 0-100): Deliverability confidence score
• severity (string): Risk level (valid, warning, or invalid)
• checks (object): Individual validation check results
• recommendations (array): Actionable advice based on validation

Step 4: Integration Best Practices

Pro Tips

1. Cache results: Email addresses rarely change—cache successful validations for 24-48 hours
2. Handle rate limits: Check X-RateLimit-Remaining header and implement exponential backoff
3. Validate on signup: Check emails during user registration, not at login
4. Use webhooks: For bulk validation, use our webhook system instead of polling

Next Steps

• Learn about Authentication methods
• Explore the API Reference
• Check out Integration Examples
• Read Best Practices

Need Help?

• Join our Discord community
• Email support: support@spamidate.com
• Browse Troubleshooting guide