🛡️ Disposable Email Detector API

Validate phone numbers for syntax, carrier/type detection (mobile / landline / VOIP), and basic disposable/temporary number detection.

Endpoint

GET https://api.tempmail.fairarena.app/check-phone?phone=%2B14155552671

Example Response

Example Usage (JavaScript)

const checkPhone = async (number) => {
  try {
    const res = await fetch(`https://api.tempmail.fairarena.app/check-phone?phone=${encodeURIComponent(number)}`);
    return await res.json();
  } catch (err) {
    console.error('Phone check error', err);
    return null;
  }
};

checkPhone('+14155552671').then(console.log);

import requests

def check_phone(phone):
  try:
    r = requests.get('https://api.tempmail.fairarena.app/check-phone', params={'phone': phone})
    return r.json()
  except Exception as e:
    print('Error:', e)
    return None

print(check_phone('+14155552671'))

Accuracy & Data Sources

Our phone-number checks combine:

• Syntax and E.164 formatting checks (highly reliable for structure)
• Number range and carrier metadata derived from public numbering plans and commercial providers
• Third-party lookups for carrier and VOIP detection where available

Typical accuracy: format detection >99%; carrier/type and disposable detection vary by country and provider coverage (commonly in the 80–95% range). Accuracy can be lower for newer ranges, ported numbers, or low-coverage regions.

Limitations

• Not a guaranteed source for reachability or active line status — reachability requires live carrier or SMS validation.
• Carrier and VOIP detection depend on external data sources that may lag behind real-world changes.
• Disposable/temporary number detection is heuristic-based and may produce false positives or negatives.
• International coverage varies by region — consult the API's rate/coverage docs for full details.

Get started with the Disposable Credential Detector API in minutes. Simply make a GET request to check if an Credential is disposable.

Endpoint

GET https://api.tempmail.fairarena.app/check?email=user@example.com

Example Request

curl "https://api.tempmail.fairarena.app/check?email=test@temp-mail.org"

Example Response

Check Email Endpoint

Determine if an email address belongs to a disposable email service.

HTTP Request

Parameters

Parameter	Type	Required	Description
email	string	Yes	The email address to check

Response Format

Response Codes

Status Code	Description
200	Success - Email checked successfully
400	Bad Request - Missing email parameter, invalid email format, or domain has no mail server
429	Too Many Requests - Rate limit exceeded
500	Internal Server Error

Error Response Examples

Missing Email Parameter (400)

Invalid Email Format (400)

Email Domain Has No Mail Server (400)

Example Usage

// Using fetch API
const checkEmail = async (email) => {
  try {
    const response = await fetch(`https://api.tempmail.fairarena.app/check?email=${encodeURIComponent(email)}`);
    const data = await response.json();
    return data.tempmail; // true = disposable, false = legitimate
  } catch (error) {
    console.error('Error checking email:', error);
    return null;
  }
};

// Usage
checkEmail('user@temp-mail.org').then(isDisposable => {
  if (isDisposable) {
    console.log('This is a disposable email!');
  } else {
    console.log('This is a legitimate email.');
  }
});

import requests

def check_disposable_email(email):
  try:
    response = requests.get(f'https://api.tempmail.fairarena.app/check?email={email}')
    data = response.json()
    return data.get('tempmail', False)
  except Exception as e:
    print(f'Error: {e}')
    return False

# Usage
is_disposable = check_disposable_email('test@10minutemail.com')
if is_disposable:
  print('Disposable email detected!')
else:
  print('Legitimate email address.')

<?php
$email = 'test@temp-mail.org';
$response = file_get_contents('https://api.tempmail.fairarena.app/check?email=' . urlencode($email));
$data = json_decode($response, true);
if (!empty($data['tempmail'])) {
  echo 'Disposable email detected!';
} else {
  echo 'Legitimate email address.';
}
?>

package main

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

func main() {
  resp, err := http.Get("https://api.tempmail.fairarena.app/check?email=test@temp-mail.org")
  if err != nil {
    fmt.Println("Request error:", err)
    return
  }
  defer resp.Body.Close()

  var data map[string]bool
  json.NewDecoder(resp.Body).Decode(&data)
  fmt.Println("Disposable:", data["tempmail"])
}

Frontend Form Validation

<form id="registrationForm">
  <input type="email" id="emailInput" required>
  <span id="emailWarning" style="color: red; display: none;">
    Disposable emails are not allowed
  </span>
  <button type="submit">Register</button>
</form>

<script>
document.getElementById('registrationForm').addEventListener('submit', async (e) => {
  e.preventDefault();

  const email = document.getElementById('emailInput').value;
  const warning = document.getElementById('emailWarning');

  try {
    const response = await fetch(`https://api.tempmail.fairarena.app/check?email=${encodeURIComponent(email)}`);
    const data = await response.json();

    if (data.tempmail) {
      warning.style.display = 'block';
      return;
    }

    warning.style.display = 'none';
    // Proceed with registration
    console.log('Email is valid, proceeding...');
  } catch (error) {
    console.error('Error validating email:', error);
  }
});
</script>

Backend Validation (Node.js/Express)

const express = require('express');
const app = express();

app.use(express.json());

// Email validation middleware
const validateEmail = async (req, res, next) => {
  const { email } = req.body;

  if (!email) {
    return res.status(400).json({ error: 'Email is required' });
  }

  try {
    // Call your disposable email detector API
    const response = await fetch(`https://api.tempmail.fairarena.app/check?email=${encodeURIComponent(email)}`);
    const data = await response.json();

    if (data.tempmail) {
      return res.status(400).json({
        error: 'Disposable emails are not allowed'
      });
    }

    next(); // Email is valid, continue
  } catch (error) {
    console.error('Email validation error:', error);
    res.status(500).json({ error: 'Validation service unavailable' });
  }
};

// Use in registration route
app.post('/register', validateEmail, (req, res) => {
  // Registration logic here
  res.json({ message: 'Registration successful' });
});

app.listen(3001, () => {
  console.log('Server running on port 3001');
});

The API includes rate limiting to prevent abuse and ensure fair usage for all users.

Current Limits

• Requests per minute: Configurable (default: 60)
• Requests per hour: Configurable (default: 1000)
• Concurrent requests: Limited

Rate Limit Headers

The API returns the following headers to help you manage your request rate:

Header	Description
X-RateLimit-Limit	Maximum requests allowed per time window
X-RateLimit-Remaining	Number of requests remaining in current window
X-RateLimit-Reset	Time when the rate limit resets (Unix timestamp)

Rate Limit Exceeded Response

Need help integrating the Disposable Email Detector API? Here are some resources to get you started.