Integrating Fuego Email Verification API with JavaScript

This guide will walk you through the process of integrating the Fuego Email Verification API into your JavaScript applications. Whether you’re using vanilla JavaScript in the browser, Node.js, or a framework like React, this guide has you covered.

Prerequisites

• A Fuego account with an API key
• Basic knowledge of JavaScript and HTTP requests

API Endpoint

The Fuego API endpoint for email verification is:

https://app.fuegoverify.com/api/v1/verify

Authentication

Authentication is done using an API token as a query parameter:

const apiToken = "YOUR_API_TOKEN";
// Token will be added to the URL as a query parameter

Method 1: Using Fetch API (Browser)

The Fetch API is available in all modern browsers and provides an easy way to make HTTP requests.

async function verifyEmail(email) {
  const apiToken = "YOUR_API_TOKEN";
  
  try {
    const response = await fetch(`https://app.fuegoverify.com/api/v1/verify?email=${encodeURIComponent(email)}&token=${apiToken}`, {
      method: "GET",
      headers: {
        "Content-Type": "application/json"
      }
    });
    
    const data = await response.json();
    
    if (!response.ok) {
      throw new Error(data.error || 'Email verification failed');
    }
    
    return data;
  } catch (error) {
    console.error("Error verifying email:", error);
    throw error;
  }
}

// Usage example
verifyEmail("[email protected]")
  .then(result => {
    console.log("Verification result:", result);
    if (result.result === "valid") {
      console.log("Email is valid!");
    } else {
      console.log("Email is invalid or risky:", result.reason);
    }
  })
  .catch(error => {
    console.error("Verification failed:", error);
  });

Method 2: Using Axios (Browser & Node.js)

Axios is a popular HTTP client that works in both browser and Node.js environments.

// First install axios: npm install axios
const axios = require('axios'); // or import axios from 'axios';

async function verifyEmail(email) {
  const apiToken = "YOUR_API_TOKEN";
  
  try {
    const response = await axios.get(`https://app.fuegoverify.com/api/v1/verify`, {
      params: { 
        email,
        token: apiToken
      },
      headers: {
        "Content-Type": "application/json"
      }
    });
    
    return response.data;
  } catch (error) {
    if (error.response && error.response.data) {
      console.error("API Error:", error.response.data);
      throw new Error(error.response.data.error || 'Email verification failed');
    }
    
    console.error("Network Error:", error.message);
    throw error;
  }
}

// Usage is the same as the previous example

Method 3: Using Node.js HTTP Module

If you’re using Node.js without any additional libraries, you can use the built-in http/https modules.

const https = require('https');

function verifyEmail(email) {
  return new Promise((resolve, reject) => {
    const apiToken = "YOUR_API_TOKEN";
    const url = `https://app.fuegoverify.com/api/v1/verify?email=${encodeURIComponent(email)}&token=${apiToken}`;
    
    const options = {
      method: 'GET',
      headers: {
        "Content-Type": "application/json"
      }
    };
    
    const req = https.request(url, options, (res) => {
      let data = '';
      
      res.on('data', (chunk) => {
        data += chunk;
      });
      
      res.on('end', () => {
        try {
          const parsedData = JSON.parse(data);
          
          if (res.statusCode >= 200 && res.statusCode < 300) {
            resolve(parsedData);
          } else {
            reject(new Error(parsedData.error || 'Email verification failed'));
          }
        } catch (error) {
          reject(new Error('Failed to parse API response'));
        }
      });
    });
    
    req.on('error', (error) => {
      reject(error);
    });
    
    req.end();
  });
}

// Usage is the same as previous examples

Working with the Response

The API returns a JSON response with various pieces of information about the email:

{
  "email": "[email protected]",
  "result": "valid", // or "invalid", "risky", "unknown"
  "reason": null, // reason for invalid or risky result
  "role": false, // true for role-based emails like "admin@" or "support@"
  "free": false, // true for free email providers like Gmail or Yahoo
  "disposable": false, // true for temporary/disposable email addresses
  "accept_all": false, // true if the domain accepts all emails
  "did_you_mean": null, // suggestion for misspelled emails
  "domain": "techcorp.com",
  "user": "alex",
  "success": true,
  "domain_insight": {
    "category": "organization",
    "name": "TechCorp Inc.",
    "industry": "Software Development",
    "country": "US",
    "ticker": "TCH",
    "employees": 3500,
    "description": "TechCorp Inc. is a leading software development company..."
  }
}

Handling Common Results

Here’s how to handle the most common verification results:

function handleVerificationResult(result) {
  switch(result.result) {
    case "valid":
      return {
        valid: true,
        message: "Email address is valid and deliverable"
      };
      
    case "invalid":
      return {
        valid: false,
        message: `Email address is invalid: ${result.reason || "Unknown reason"}`
      };
      
    case "risky":
      return {
        valid: false,
        risky: true,
        message: `Email address is risky: ${result.reason || "Unknown reason"}`
      };
      
    case "unknown":
      return {
        valid: null,
        message: "Verification result is inconclusive"
      };
      
    default:
      return {
        valid: null,
        message: "Unknown verification result"
      };
  }
}

// Example usage
verifyEmail("[email protected]")
  .then(result => {
    const status = handleVerificationResult(result);
    console.log(status.message);
    
    // You might also want to use the domain intelligence
    if (result.domain_insight) {
      console.log(`Organization: ${result.domain_insight.name}`);
      console.log(`Industry: ${result.domain_insight.industry}`);
    }
  })
  .catch(error => {
    console.error("Verification failed:", error);
  });

Full Example in a React Component

Here’s how you might implement email verification in a React form component:

import React, { useState } from 'react';
import axios from 'axios';

function EmailVerificationForm() {
  const [email, setEmail] = useState('');
  const [isVerifying, setIsVerifying] = useState(false);
  const [result, setResult] = useState(null);
  const [error, setError] = useState(null);
  
  const verifyEmail = async (email) => {
    const apiToken = "YOUR_API_TOKEN";
    
    try {
      const response = await axios.get(`https://app.fuegoverify.com/api/v1/verify`, {
        params: { 
          email,
          token: apiToken
        },
        headers: {
          "Content-Type": "application/json"
        }
      });
      
      return response.data;
    } catch (error) {
      if (error.response && error.response.data) {
        throw new Error(error.response.data.error || 'Email verification failed');
      }
      
      throw error;
    }
  };
  
  const handleSubmit = async (e) => {
    e.preventDefault();
    setIsVerifying(true);
    setResult(null);
    setError(null);
    
    try {
      const verificationResult = await verifyEmail(email);
      setResult(verificationResult);
    } catch (err) {
      setError(err.message || 'Verification failed');
    } finally {
      setIsVerifying(false);
    }
  };
  
  const getStatusColor = () => {
    if (!result) return '';
    
    switch(result.result) {
      case 'valid': return 'text-success';
      case 'risky': return 'text-warning';
      case 'invalid': return 'text-danger';
      default: return 'text-secondary';
    }
  };
  
  return (
    <div className="email-verification-form">
      <form onSubmit={handleSubmit}>
        <div className="form-group">
          <label htmlFor="email">Email address</label>
          <input
            type="email"
            className="form-control"
            id="email"
            value={email}
            onChange={(e) => setEmail(e.target.value)}
            required
          />
        </div>
        
        <button 
          type="submit" 
          className="btn btn-primary"
          disabled={isVerifying || !email}
        >
          {isVerifying ? 'Verifying...' : 'Verify Email'}
        </button>
      </form>
      
      {error && (
        <div className="alert alert-danger mt-3">
          Error: {error}
        </div>
      )}
      
      {result && (
        <div className="verification-result mt-4">
          <h3>Verification Result</h3>
          
          <div className={`result-status ${getStatusColor()}`}>
            <strong>Status:</strong> {result.result.toUpperCase()}
            {result.reason && ` (${result.reason})`}
          </div>
          
          {result.did_you_mean && (
            <div className="did-you-mean">
              <strong>Did you mean:</strong> {result.did_you_mean}
            </div>
          )}
          
          {result.domain_insight && (
            <div className="domain-insights mt-3">
              <h4>Domain Insights</h4>
              <table className="table">
                <tbody>
                  <tr>
                    <td>Organization:</td>
                    <td>{result.domain_insight.name || 'Unknown'}</td>
                  </tr>
                  <tr>
                    <td>Industry:</td>
                    <td>{result.domain_insight.industry || 'Unknown'}</td>
                  </tr>
                  <tr>
                    <td>Employees:</td>
                    <td>{result.domain_insight.employees || 'Unknown'}</td>
                  </tr>
                  <tr>
                    <td>Country:</td>
                    <td>{result.domain_insight.country || 'Unknown'}</td>
                  </tr>
                </tbody>
              </table>
            </div>
          )}
        </div>
      )}
    </div>
  );
}

export default EmailVerificationForm;

Rate Limiting and Error Handling

The Fuego API has rate limits to ensure reliable service for all users. Your application should be prepared to handle rate limit errors (HTTP 429) by implementing appropriate backoff strategies.

async function verifyEmailWithRetry(email, maxRetries = 3) {
  let retries = 0;
  
  while (retries < maxRetries) {
    try {
      return await verifyEmail(email);
    } catch (error) {
      if (error.response && error.response.status === 429) {
        // Rate limited, wait and retry
        retries++;
        const backoffTime = retries * 1000; // Exponential backoff
        console.log(`Rate limited, retrying in ${backoffTime}ms (Attempt ${retries}/${maxRetries})`);
        await new Promise(resolve => setTimeout(resolve, backoffTime));
      } else {
        // Other error, don't retry
        throw error;
      }
    }
  }
  
  throw new Error('Max retries exceeded for email verification');
}

Conclusion

You now have everything you need to integrate the Fuego Email Verification API into your JavaScript applications. This integration will help you ensure that the email addresses collected by your application are valid and deliverable, reducing bounce rates and improving your email campaign performance.

For more information and advanced usage, refer to the complete API documentation.

Pricing

For information about pricing, see our pricing page where you can calculate the exact cost for your email verification needs.