Fast Validation

The fast validation endpoint provides optimized real-time validation with minimal checks, perfect for form validation and instant feedback scenarios where speed is critical.

Endpoint Details

GET

https://valid-mint-e-mail-domain-validator.p.rapidapi.com/v1/fast-validate

Lightning Fast

This endpoint is optimized for sub-20ms response times, making it perfect for real-time validation as users type in forms.

Request Parameters

Query Parameters (GET)

Parameter	Type	Required	Description
domain	string	✓	Domain to validate (e.g., “example.com” or “user@example.com”)

Response Format

Success Response

{
  "request_id": "550e8400-e29b-41d4-a716-446655440000",
  "domain": "gmail.com",
  "is_valid": true,
  "is_disposable": false
}

Response Fields

Field	Type	Description
request_id	string	Unique request identifier
domain	string	Validated domain
is_valid	boolean	Basic format validation result
is_disposable	boolean	Whether domain is disposable

What’s Validated?

Domain Format

✅ RFC-compliant validation

Checks domain format, length, and character validity

Disposable Detection

✅ 60k+ disposable domains

Instant lookup using optimized filters

Not Included

⏭️ For comprehensive checks:

DNS, MX records, SPF/DKIM/DMARC analysis available in /v1/validate

Performance

Operation	Time
Domain parsing	<1ms
Format validation	<1ms
Disposable lookup	<1ms
Total response	~10-20ms

Code Examples

Node.js (HTTPS)

const https = require('https');

const options = {
    method: 'GET',
    hostname: 'valid-mint-e-mail-domain-validator.p.rapidapi.com',
    port: null,
    path: '/v1/fast-validate?domain=gmail.com',
    headers: {
        'x-rapidapi-key': 'YOUR_RAPIDAPI_KEY',
        'x-rapidapi-host': 'valid-mint-e-mail-domain-validator.p.rapidapi.com'
    }
};

const req = https.request(options, function (res) {
    const chunks = [];

    res.on('data', function (chunk) {
        chunks.push(chunk);
    });

    res.on('end', function () {
        const body = Buffer.concat(chunks);
        console.log(body.toString());
    });
});

req.end();

JavaScript (Fetch)

const url = 'https://valid-mint-e-mail-domain-validator.p.rapidapi.com/v1/fast-validate?domain=gmail.com';

const options = {
    method: 'GET',
    headers: {
        'x-rapidapi-key': 'YOUR_RAPIDAPI_KEY',
        'x-rapidapi-host': 'valid-mint-e-mail-domain-validator.p.rapidapi.com'
    }
};

try {
    const response = await fetch(url, options);
    const result = await response.json();
    console.log(result);
} catch (error) {
    console.error('Error:', error);
}

Python

import requests

url = "https://valid-mint-e-mail-domain-validator.p.rapidapi.com/v1/fast-validate"

querystring = {"domain": "gmail.com"}

headers = {
    "x-rapidapi-key": "YOUR_RAPIDAPI_KEY",
    "x-rapidapi-host": "valid-mint-e-mail-domain-validator.p.rapidapi.com"
}

response = requests.get(url, headers=headers, params=querystring)

if response.status_code == 200:
    print(response.json())
else:
    print(f"Error: {response.status_code}")

PHP

<?php
$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => "https://valid-mint-e-mail-domain-validator.p.rapidapi.com/v1/fast-validate?domain=gmail.com",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "x-rapidapi-host: valid-mint-e-mail-domain-validator.p.rapidapi.com",
        "x-rapidapi-key: YOUR_RAPIDAPI_KEY"
    ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
    echo "cURL Error #:" . $err;
} else {
    echo $response;
}
?>

Java

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class FastEmailValidator {
    public static void main(String[] args) throws IOException, InterruptedException {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://valid-mint-e-mail-domain-validator.p.rapidapi.com/v1/fast-validate?domain=gmail.com"))
            .header("x-rapidapi-key", "YOUR_RAPIDAPI_KEY")
            .header("x-rapidapi-host", "valid-mint-e-mail-domain-validator.p.rapidapi.com")
            .method("GET", HttpRequest.BodyPublishers.noBody())
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

C#

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var client = new HttpClient();
        var request = new HttpRequestMessage
        {
            Method = HttpMethod.Get,
            RequestUri = new Uri("https://valid-mint-e-mail-domain-validator.p.rapidapi.com/v1/fast-validate?domain=gmail.com"),
            Headers =
            {
                { "x-rapidapi-key", "YOUR_RAPIDAPI_KEY" },
                { "x-rapidapi-host", "valid-mint-e-mail-domain-validator.p.rapidapi.com" },
            },
        };

        using (var response = await client.SendAsync(request))
        {
            response.EnsureSuccessStatusCode();
            var body = await response.Content.ReadAsStringAsync();
            Console.WriteLine(body);
        }
    }
}

Real-time Form Validation

Perfect for validating email inputs as users type:

Vanilla JavaScript

class RealTimeEmailValidator {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://valid-mint-e-mail-domain-validator.p.rapidapi.com';
    this.cache = new Map();
    this.debounceTimeout = null;
  }

  async validateEmail(email) {
    // Check cache first
    if (this.cache.has(email)) {
      return this.cache.get(email);
    }

    try {
      const response = await fetch(
        `${this.baseUrl}/v1/fast-validate?domain=${encodeURIComponent(email)}`,
        {
          headers: {
            'x-rapidapi-key': this.apiKey,
            'x-rapidapi-host': 'valid-mint-e-mail-domain-validator.p.rapidapi.com'
          }
        }
      );

      if (!response.ok) {
        throw new Error(`HTTP ${response.status}`);
      }

      const result = await response.json();

      // Cache result for 5 minutes
      this.cache.set(email, result);
      setTimeout(() => this.cache.delete(email), 5 * 60 * 1000);

      return result;
    } catch (error) {
      console.error('Validation error:', error);
      return { error: error.message };
    }
  }

  setupFormValidation(inputElement, errorElement) {
    inputElement.addEventListener('input', (e) => {
      const email = e.target.value;

      // Clear previous timeout
      if (this.debounceTimeout) {
        clearTimeout(this.debounceTimeout);
      }

      // Debounce API calls
      this.debounceTimeout = setTimeout(async () => {
        if (email && email.includes('@')) {
          const result = await this.validateEmail(email);

          if (result.error) {
            this.showError(errorElement, 'Validation failed. Please check your connection.');
          } else if (!result.is_valid) {
            this.showError(errorElement, 'Invalid email format');
          } else if (result.is_disposable) {
            this.showError(errorElement, 'Disposable email addresses are not allowed');
          } else {
            this.clearError(errorElement);
          }
        } else {
          this.clearError(errorElement);
        }
      }, 300); // 300ms debounce
    });
  }

  showError(errorElement, message) {
    errorElement.textContent = message;
    errorElement.style.display = 'block';
    errorElement.style.color = 'red';
  }

  clearError(errorElement) {
    errorElement.style.display = 'none';
  }
}

// Usage
const validator = new RealTimeEmailValidator('YOUR_RAPIDAPI_KEY');
const emailInput = document.getElementById('email');
const errorDiv = document.getElementById('email-error');

validator.setupFormValidation(emailInput, errorDiv);

React Hook

import { useState, useCallback, useEffect } from 'react';

function useEmailValidation(apiKey) {
  const [cache] = useState(new Map());

  const validateEmail = useCallback(async (email) => {
    if (!email || !email.includes('@')) {
      return null;
    }

    // Check cache
    if (cache.has(email)) {
      return cache.get(email);
    }

    try {
      const response = await fetch(
        `https://valid-mint-e-mail-domain-validator.p.rapidapi.com/v1/fast-validate?domain=${encodeURIComponent(email)}`,
        {
          headers: {
            'x-rapidapi-key': apiKey,
            'x-rapidapi-host': 'valid-mint-e-mail-domain-validator.p.rapidapi.com'
          }
        }
      );

      if (!response.ok) {
        throw new Error(`HTTP ${response.status}`);
      }

      const result = await response.json();

      // Cache result
      cache.set(email, result);
      setTimeout(() => cache.delete(email), 5 * 60 * 1000);

      return result;
    } catch (error) {
      console.error('Validation error:', error);
      return { error: error.message };
    }
  }, [apiKey, cache]);

  return { validateEmail };
}

function EmailInput({ apiKey }) {
  const [email, setEmail] = useState('');
  const [error, setError] = useState('');
  const [isValidating, setIsValidating] = useState(false);
  const { validateEmail } = useEmailValidation(apiKey);

  useEffect(() => {
    const timeoutId = setTimeout(async () => {
      if (email) {
        setIsValidating(true);
        const result = await validateEmail(email);

        if (result?.error) {
          setError('Validation failed');
        } else if (result && !result.is_valid) {
          setError('Invalid email format');
        } else if (result?.is_disposable) {
          setError('Disposable emails not allowed');
        } else if (result) {
          setError('');
        }

        setIsValidating(false);
      } else {
        setError('');
      }
    }, 300);

    return () => clearTimeout(timeoutId);
  }, [email, validateEmail]);

  return (
    <div>
      <input
        type="email"
        value={email}
        onChange={(e) => setEmail(e.target.value)}
        placeholder="Enter email address"
        style={{
          borderColor: error ? 'red' : 'initial',
          padding: '8px',
          borderRadius: '4px'
        }}
      />
      {isValidating && (
        <span style={{ color: 'blue', fontSize: '12px' }}>
          Validating...
        </span>
      )}
      {error && (
        <div style={{ color: 'red', fontSize: '12px' }}>
          {error}
        </div>
      )}
    </div>
  );
}

Vue.js

<template>
  <div>
    <input
      v-model="email"
      type="email"
      placeholder="Enter email address"
      :class="{ error: error }"
      @input="handleInput"
    />
    <div v-if="isValidating" class="validating">
      Validating...
    </div>
    <div v-if="error" class="error-message">
      {{ error }}
    </div>
  </div>
</template>

<script>
import { ref, computed } from 'vue'

export default {
  props: {
    apiKey: {
      type: String,
      required: true
    }
  },
  setup(props) {
    const email = ref('')
    const error = ref('')
    const isValidating = ref(false)
    const cache = new Map()
    let debounceTimeout = null

    const validateEmail = async (emailValue) => {
      if (!emailValue || !emailValue.includes('@')) {
        return null
      }

      if (cache.has(emailValue)) {
        return cache.get(emailValue)
      }

      try {
        const response = await fetch(
          `https://valid-mint-e-mail-domain-validator.p.rapidapi.com/v1/fast-validate?domain=${encodeURIComponent(emailValue)}`,
          {
            headers: {
              'x-rapidapi-key': props.apiKey,
              'x-rapidapi-host': 'valid-mint-e-mail-domain-validator.p.rapidapi.com'
            }
          }
        )

        const result = await response.json()
        cache.set(emailValue, result)
        setTimeout(() => cache.delete(emailValue), 5 * 60 * 1000)

        return result
      } catch (err) {
        console.error('Validation error:', err)
        return { error: err.message }
      }
    }

    const handleInput = () => {
      if (debounceTimeout) {
        clearTimeout(debounceTimeout)
      }

      debounceTimeout = setTimeout(async () => {
        if (email.value) {
          isValidating.value = true
          const result = await validateEmail(email.value)

          if (result?.error) {
            error.value = 'Validation failed'
          } else if (result && !result.is_valid) {
            error.value = 'Invalid email format'
          } else if (result?.is_disposable) {
            error.value = 'Disposable emails not allowed'
          } else if (result) {
            error.value = ''
          }

          isValidating.value = false
        } else {
          error.value = ''
        }
      }, 300)
    }

    return {
      email,
      error,
      isValidating,
      handleInput
    }
  }
}
</script>

<style>
.error {
  border-color: red;
}
.error-message {
  color: red;
  font-size: 12px;
}
.validating {
  color: blue;
  font-size: 12px;
}
</style>

Example Responses

Valid Email Domain

{
  "request_id": "550e8400-e29b-41d4-a716-446655440000",
  "domain": "gmail.com",
  "is_valid": true,
  "is_disposable": false
}

Disposable Email Domain

{
  "request_id": "550e8400-e29b-41d4-a716-446655440001",
  "domain": "10minutemail.com",
  "is_valid": true,
  "is_disposable": true
}

Invalid Email Format

{
  "request_id": "550e8400-e29b-41d4-a716-446655440002",
  "domain": "invalid-domain",
  "is_valid": false,
  "is_disposable": false
}

Error Responses

Invalid Domain Format

{
  "error": "Invalid domain format",
  "error_code": "INVALID_DOMAIN",
  "request_id": "550e8400-e29b-41d4-a716-446655440000",
  "timestamp": "2024-01-20T10:30:00Z"
}

Rate Limit Exceeded

{
  "error": "Rate limit exceeded. Please retry after 3600 seconds.",
  "error_code": "RATE_LIMIT_EXCEEDED",
  "request_id": "550e8400-e29b-41d4-a716-446655440000",
  "timestamp": "2024-01-20T10:30:00Z"
}

Best Practices

Debounce Input

Add 200-300ms debounce to avoid excessive API calls while users are typing

Cache Results

Cache validation results locally for repeated checks of the same domain

Handle Errors Gracefully

Always implement fallback validation when API calls fail

Progressive Enhancement

Use fast validation for instant feedback, then full validation on form submit

When to Use Fast vs Full Validation

Scenario	Recommended Endpoint	Reason
Real-time form validation	Fast Validation	Sub-20ms response for instant feedback
Email signup forms	Fast Validation	Quick disposable detection
Email list cleaning	Full Validation	Comprehensive validation with risk scoring
Final verification	Full Validation	Complete DNS and authentication checks

Tip

Remember to replace YOUR_RAPIDAPI_KEY with your actual API key from the RapidAPI dashboard.