Forem: Alexey D

Language Detection API: Detect 100+ Languages with Confidence Score (Free Tier)

Alexey D — Tue, 05 May 2026 09:34:36 +0000

Need to detect what language a piece of text is written in? Whether you are building a multilingual chatbot, content moderation system, or routing engine — here is how to do it with one API call.

Language Detector Pro API

RapidAPI link: https://rapidapi.com/adunaev8419/api/language-detector-pro

Supports 100+ languages, returns confidence score, works on short texts too. Free tier: 50 requests/hour.

Python Example

import requests

url = "https://language-detector-pro.p.rapidapi.com/detect"
headers = {
    "X-RapidAPI-Key": "YOUR_KEY",
    "Content-Type": "application/json"
}

texts = ["Hello world", "Bonjour le monde", "Привет мир", "こんにちは"]

for text in texts:
    r = requests.post(url, json={"text": text}, headers=headers)
    d = r.json()
    print(f"{text:<20} -> {d['language_name']} ({d['confidence']*100:.0f}%)")

# Hello world          -> English  (99%)
# Bonjour le monde     -> French   (98%)
# Привет мир           -> Russian  (99%)
# こんにちは              -> Japanese (99%)

JavaScript Example

const res = await fetch("https://language-detector-pro.p.rapidapi.com/detect", {
  method: "POST",
  headers: {
    "X-RapidAPI-Key": "YOUR_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({ text: "Wie geht es Ihnen?" })
});
const data = await res.json();
console.log(data.language_name); // "German"
console.log(data.confidence);    // 0.97

Batch Processing

r = requests.post(
    "https://language-detector-pro.p.rapidapi.com/batch",
    json={"texts": ["Hello", "Bonjour", "Привет", "Hola", "Ciao"]},
    headers=headers
)
for item in r.json()["results"]:
    print(item["detected_language"], item["language_name"])
# en English / fr French / ru Russian / es Spanish / it Italian

Use Cases

Multilingual chatbots — route to correct response template by language
Content moderation — apply language-specific rules
Customer support — auto-assign tickets to right-language agents
Analytics — understand your global audience breakdown

Pricing

Plan	Price	Requests/hr
BASIC	Free	50
PRO	$9.99/mo	1,000
ULTRA	$24.99/mo	8,000

Try it free: https://rapidapi.com/adunaev8419/api/language-detector-pro

GitHub: https://github.com/adun8419/language-detector-pro-api

Email Validation API: Detect Disposable Emails and Invalid MX Records (Free)

Alexey D — Tue, 05 May 2026 09:28:22 +0000

Building a registration or newsletter form? Here is how to validate emails properly — catch typos, disposable addresses, and invalid MX records before they pollute your database.

Why Simple Regex Fails

A regex like ^[^@]+@[^@]+\.[^@]+$ will pass:

❌ user@fakemx.xyz (no mail server exists)
❌ test@mailinator.com (disposable, will be abandoned)
❌ plainaddress on some implementations

You need real MX record lookup + disposable domain detection.

Email Validator Pro API

RapidAPI link: https://rapidapi.com/adunaev8419/api/email-validator-pro11

Returns: MX validity, disposable flag, quality score (0-100), format check.

Free tier: 30 requests/hour.

Python Example

import requests

url = "https://email-validator-pro11.p.rapidapi.com/validate"
headers = {
    "X-RapidAPI-Key": "YOUR_KEY",
    "Content-Type": "application/json"
}

r = requests.post(url, json={"email": "user@gmail.com"}, headers=headers)
print(r.json())
# {
#   "is_valid": true,
#   "mx_valid": true,
#   "is_disposable": false,
#   "quality_score": 100,
#   "format_valid": true
# }

# Try a disposable address
r2 = requests.post(url, json={"email": "test@mailinator.com"}, headers=headers)
print(r2.json())
# {"is_valid": false, "is_disposable": true, "quality_score": 0}

JavaScript Example

const res = await fetch("https://email-validator-pro11.p.rapidapi.com/validate", {
  method: "POST",
  headers: {
    "X-RapidAPI-Key": "YOUR_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({ email: "user@example.com" })
});
const data = await res.json();
if (!data.is_valid || data.is_disposable) {
  console.log("Reject this email");
}

Batch Validation — Clean Your Entire List

emails = ["user@gmail.com", "fake@mailinator.com", "bad-format", "contact@company.io"]

r = requests.post(
    "https://email-validator-pro11.p.rapidapi.com/batch",
    json={"emails": emails},
    headers=headers
)
results = r.json()
valid = [e for e in results["results"] if e["is_valid"]]
print(f"{len(valid)}/{len(emails)} emails are valid")

Use Cases

User registration — block disposable emails at signup
Email campaigns — reduce bounce rate before sending
CRM import — validate bulk contact lists
B2B lead gen — score email quality before outreach

Pricing

Plan	Price	Requests/hr
BASIC	Free	30
PRO	$9.99/mo	500
ULTRA	$24.99/mo	5,000

Try it free: https://rapidapi.com/adunaev8419/api/email-validator-pro11

GitHub: https://github.com/adun8419/email-validator-pro-api

Phone Number Validation API: The Complete Guide (Free Tier Available)

Alexey D — Tue, 05 May 2026 09:28:02 +0000

Building a form with a phone number field? Tired of fake numbers slipping through your validation? Here's how to add rock-solid phone validation in under 5 minutes — for free.

Why Basic Regex Isn't Enough

Most developers start with a regex like ^\+?[0-9]{10,15}$. But this misses:

❌ Invalid country codes (+999)
❌ Numbers that are syntactically valid but don't exist
❌ No carrier or line type info (mobile vs landline)
❌ No formatting standardization

A proper validation API handles all of this.

Phone Validator Pro API

RapidAPI link: https://rapidapi.com/adunaev8419/api/phone-validator-pro1

Returns: carrier, country, line type (MOBILE/LANDLINE/VOIP), E.164 format, timezone.

Free tier: 30 requests/hour — enough for most projects.

Python Example

import requests

url = "https://phone-validator-pro1.p.rapidapi.com/validate"
headers = {
    "X-RapidAPI-Key": "YOUR_KEY",
    "Content-Type": "application/json"
}

r = requests.post(url, json={"phone": "+79001234567"}, headers=headers)
print(r.json())
# {
#   "is_valid": true,
#   "country": "Russia",
#   "carrier": "Tele2",
#   "line_type": "MOBILE",
#   "e164_format": "+79001234567",
#   "timezone": "Europe/Moscow"
# }

JavaScript / Node.js Example

const response = await fetch('https://phone-validator-pro1.p.rapidapi.com/validate', {
  method: 'POST',
  headers: {
    'X-RapidAPI-Key': 'YOUR_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ phone: '+447911123456' })
});

const data = await response.json();
console.log(data.line_type); // "MOBILE"
console.log(data.country);   // "United Kingdom"

Batch Validation

Need to clean a list of numbers? Use the /batch endpoint:

phones = [
    {"phone": "+79001234567"},
    {"phone": "+447911123456"},
    {"phone": "+12025551234"}
]

r = requests.post(
    "https://phone-validator-pro1.p.rapidapi.com/batch",
    json={"phones": phones},
    headers=headers
)
results = r.json()
# Returns validation result for each number in one call

cURL

curl -X POST "https://phone-validator-pro1.p.rapidapi.com/validate" \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"phone": "+79001234567"}'

When to Use This

User registration forms — block fake numbers before they hit your DB
SMS campaigns — filter out landlines and invalid numbers before sending
CRM data cleaning — validate imported contact lists in batch
E-commerce checkout — ensure delivery contact is reachable

Pricing

Plan	Price	Requests/hr
BASIC	Free	30
PRO	$9.99/mo	500
ULTRA	$24.99/mo	5,000

Try it free: https://rapidapi.com/adunaev8419/api/phone-validator-pro1

GitHub with more examples: https://github.com/adun8419/phone-validator-pro-api

Language Detection API — 100+ Languages with Confidence Score

Alexey D — Tue, 05 May 2026 08:20:30 +0000

Language detection is essential for any app handling user-generated content — routing, filtering, analytics, personalization.

Language Detector Pro identifies the language of any text and returns an ISO 639-1 code with confidence score.

What you get

100+ languages supported
Confidence score 0-1
ISO 639-1 code + full language name
Works on short texts: tweets, reviews, chat messages
Batch: up to 100 texts per request

Quick start

Python

import requests

url = "https://language-detector-pro.p.rapidapi.com/detect"
headers = {"X-RapidAPI-Key": "YOUR_KEY", "Content-Type": "application/json"}

r = requests.post(url, json={"text": "Bonjour, comment allez-vous?"}, headers=headers)
print(r.json())
# {"detected_language": "fr", "language_name": "French", "confidence": 0.98}

cURL

curl -X POST https://language-detector-pro.p.rapidapi.com/detect \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d "{"text": "Hola mundo"}"

Batch

payload = {"texts": ["Hello world", "Привет мир", "Hola mundo"]}
r = requests.post(".../batch", json=payload, headers=headers)

Use cases

Support ticket routing to language-specific teams
Content moderation by language
E-commerce localization
Chatbot language switching

Pricing

Plan	Price	Rate limit
BASIC	Free	50 req/hr
PRO	$9.99/mo	1000 req/hr
ULTRA	$24.99/mo	8000 req/hr

Try it free: https://rapidapi.com/adunaev8419/api/language-detector-pro

Email Validation API — MX Check, Disposable Detection & Quality Score

Alexey D — Tue, 05 May 2026 08:14:54 +0000

Regex tells you if an email looks valid. It doesn't tell you if it actually works.

user@gmaill.com passes regex. It fails MX check. user@mailinator.com is a throwaway that will never convert.

Email Validator Pro catches both.

What you get

✅ Syntax validation
📡 MX record check (does the domain actually receive email?)
🚫 Disposable email detection (mailinator, guerrilla mail, etc.)
📊 Quality score 0–100
🌐 Domain info

Quick start

Python

import requests

url = "https://email-validator-pro11.p.rapidapi.com/validate"
headers = {
    "X-RapidAPI-Key": "YOUR_KEY",
    "Content-Type": "application/json"
}
payload = {"email": "user@gmail.com"}

r = requests.post(url, json=payload, headers=headers)
print(r.json())

Response:

{
  "email": "user@gmail.com",
  "is_valid": true,
  "syntax_valid": true,
  "mx_valid": true,
  "is_disposable": false,
  "quality_score": 100,
  "reason": "ok"
}

JavaScript

const res = await fetch("https://email-validator-pro11.p.rapidapi.com/validate", {
  method: "POST",
  headers: {
    "X-RapidAPI-Key": "YOUR_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({ email: "test@mailinator.com" })
});
const data = await res.json();
console.log(data); // is_disposable: true, quality_score: 0

cURL

curl -X POST https://email-validator-pro11.p.rapidapi.com/validate \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "user@example.com"}'

Batch validation

Validate up to 50 emails in one call:

payload = {
  "emails": ["user@gmail.com", "test@mailinator.com", "info@github.com"]
}
r = requests.post(".../batch", json=payload, headers=headers)

Use cases

Signup forms — block disposable emails before they pollute your DB
Email campaigns — clean your list before sending, reduce bounce rate
Lead generation — score leads by email quality
B2B SaaS — verify work emails vs personal addresses
Marketplace — prevent fake account creation

Pricing

Plan	Price	Rate limit
BASIC	Free	30 req/hr
PRO	$9.99/mo	500 req/hr
ULTRA	$24.99/mo	5000 req/hr

Try it

👉 Email Validator Pro on RapidAPI

Free tier, no credit card required.

We were seeing 25% bounce rate on our email campaigns. Turned out 1 in 4 signups used a disposable address. This API dropped our bounce rate to under 3% in one week.

Phone Number Validation API — Carrier, Country & Line Type in One Call

Alexey D — Tue, 05 May 2026 08:14:53 +0000

Phone validation is one of those things every app needs but nobody wants to build.

Regex catches syntax. It doesn't catch whether +79001234567 is Tele2 in Russia, or whether a number is landline vs mobile vs VoIP.

Phone Validator Pro solves this with a single API call.

What you get

✅ Valid/invalid flag
🌍 Country + country code
📡 Carrier name
📱 Line type: MOBILE / LANDLINE / VOIP
🔢 E164, national, international format
🕐 Timezones for the number

Works for 200+ countries. Response under 100ms.

Quick start

Python

import requests

url = "https://phone-validator-pro1.p.rapidapi.com/validate"
headers = {
    "X-RapidAPI-Key": "YOUR_KEY",
    "Content-Type": "application/json"
}
payload = {"phone": "+79001234567", "country_code": "RU"}

r = requests.post(url, json=payload, headers=headers)
print(r.json())

Response:

{
  "is_valid": true,
  "country": "Russia",
  "carrier": "Tele2",
  "line_type": "MOBILE",
  "e164_format": "+79001234567",
  "international_format": "+7 900 123-45-67"
}

JavaScript

const res = await fetch("https://phone-validator-pro1.p.rapidapi.com/validate", {
  method: "POST",
  headers: {
    "X-RapidAPI-Key": "YOUR_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({ phone: "+447911123456" })
});
const data = await res.json();
console.log(data);

cURL

curl -X POST https://phone-validator-pro1.p.rapidapi.com/validate \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"phone": "+14155552671"}'

Batch validation

Need to validate a list? Use /batch — up to 50 numbers per request:

payload = {
  "phones": [
    {"phone": "+79001234567"},
    {"phone": "+447911123456"},
    {"phone": "+14155552671"}
  ]
}

Use cases

User registration — reject invalid numbers at signup
SMS campaigns — filter out landlines before sending
Fraud detection — flag VoIP numbers in payment flows
CRM enrichment — add carrier and country to contacts
Delivery apps — validate customer phone before dispatch

Pricing

Plan	Price	Rate limit
BASIC	Free	30 req/hr
PRO	$9.99/mo	500 req/hr
ULTRA	$24.99/mo	5000 req/hr

Try it

👉 Phone Validator Pro on RapidAPI

Free tier, no credit card required.

Built this after spending 3 hours debugging why an SMS campaign had a 40% bounce rate. Half the numbers were landlines. One API call would have caught them all.

Domain WHOIS API: Get Registration and Expiry Data in One Call

Alexey D — Tue, 05 May 2026 07:16:30 +0000

Most businesses and security teams need domain information — but WHOIS lookups are either slow, outdated, or behind paywalls.

I built Domain WHOIS API — instant access to registration data, expiry dates, nameservers, and IP addresses for any domain.

What it does

Single endpoint: POST /whois

Returns:

Registrar name
Creation date
Expiration date (+ days until expiry)
Last updated date
Domain status
Nameservers
Country
IP address

Quick start

Python

import requests

url = "https://domain-whois-lookup.p.rapidapi.com/whois"
headers = {
    "X-RapidAPI-Key": "YOUR_KEY",
    "Content-Type": "application/json"
}
payload = {"domain": "github.com"}

r = requests.post(url, json=payload, headers=headers)
print(r.json())

Use cases

Domain monitoring — track expiry dates
Brand protection — monitor competitors
Security — identify ownership and registrars
Lead research — extract contact info
Infrastructure mapping — discover nameservers

Pricing

Plan	Price	Rate limit
BASIC	Free	50 req/hr
PRO	$9.99/mo	1,000 req/hr
ULTRA	$29.99/mo	10,000 req/hr

Domain WHOIS Lookup on RapidAPI

Free tier available. No credit card.

Domain WHOIS API: Get Registration, Expiry and Ownership Data in One Call

Alexey D — Tue, 05 May 2026 07:16:28 +0000

Most businesses and security teams need domain information — but WHOIS lookups are either slow, outdated, or behind paywalls.

I built Domain WHOIS API — instant access to registration data, expiry dates, nameservers, and IP addresses for any domain.

What it does

Single endpoint: POST /whois

Returns:

Registrar name
Creation date
Expiration date (+ days until expiry)
Last updated date
Domain status (active/expired/locked)
Nameservers
Country
IP address
Registrant organization

Perfect for: domain monitoring, cybersecurity, lead research, brand protection.

Quick start

Python

import requests

url = "https://domain-whois-lookup.p.rapidapi.com/whois"
headers = {
    "X-RapidAPI-Key": "YOUR_KEY",
    "Content-Type": "application/json"
}
payload = {"domain": "github.com"}

r = requests.post(url, json=payload, headers=headers)
print(r.json())

Response:

{
  "domain": "github.com",
  "registrar": "MarkMonitor, Inc.",
  "creation_date": "2007-10-09T18:20:50+00:00",
  "expiration_date": "2026-10-09T18:20:50+00:00",
  "days_until_expiry": 158,
  "status": ["clientDeleteProhibited", "clientTransferProhibited"],
  "name_servers": ["ns1.verifydomains.com", "ns2.verifydomains.com"],
  "country": "United States",
  "ip_address": "140.82.114.4"
}

JavaScript

const response = await fetch("https://domain-whois-lookup.p.rapidapi.com/whois", {
  method: "POST",
  headers: {
    "X-RapidAPI-Key": "YOUR_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({ domain: "amazon.com" })
});
const data = await response.json();
console.log(data);

Use cases

Domain monitoring — track when domains are about to expire
Brand protection — monitor competitor domains
Security/OSINT — identify domain ownership and registrars
Lead research — find contact info from WHOIS records
Infrastructure mapping — discover nameservers and IPs

Pricing

Plan	Price	Rate limit
BASIC	Free	50 req/hr
PRO	$9.99/mo	1,000 req/hr
ULTRA	$29.99/mo	10,000 req/hr

Try it

Domain WHOIS Lookup on RapidAPI

Free tier available. No credit card required.

Built this because bulk WHOIS checks are expensive, slow, or outdated. This pulls live data and returns it in milliseconds.

Feedback welcome — especially on additional data points you'd like to see.

Email Validator API: Prevent Fake Signups and Bounce Rates in Real Time

Alexey D — Tue, 05 May 2026 07:09:00 +0000

Email validation seems simple until you do it at scale.

Most validation tools check:

✓ Syntax (is it formatted right?)
✗ MISSING: Is the email server real? (MX records)
✗ MISSING: Is it a disposable email?

Missing those two? Your database fills with fake emails, hard bounces, and spam traps.

Email Validator Pro API checks all three in one call.

What it does

POST /validate

Syntax validation (RFC standard)
MX record lookup (mail server exists)
Disposable domain detection (20,000+ known services)
Quality score 0-100
Reason codes (invalid_syntax, no_mx_record, disposable_email)

Use cases

Form validation — reject fake emails before storing them
Lead quality — score leads before sales outreach
List cleaning — bulk validate 50k+ emails before campaign
Signup compliance — prevent spam account creation
CRM enrichment — flag low-quality emails in existing database

Quick example

import requests

url = "https://email-validator-pro.p.rapidapi.com/validate"
headers = {
    "X-RapidAPI-Key": "YOUR_KEY",
    "Content-Type": "application/json"
}
payload = {"email": "john@gmail.com"}

r = requests.post(url, json=payload, headers=headers)
print(r.json())

Response:

{
  "email": "john@gmail.com",
  "is_valid": true,
  "syntax_valid": true,
  "mx_valid": true,
  "is_disposable": false,
  "domain": "gmail.com",
  "mx_records": ["alt1.gmail-smtp-in.l.google.com", "alt2.gmail-smtp-in.l.google.com"],
  "quality_score": 100,
  "reason": "ok"
}

Real cost of bad email data

A typical email list without validation:

25-30% bounce rate (email doesn't exist)
5-10% spam traps (blacklisted addresses)
10-15% disposable (fake, short-lived emails)

That's 40-55% wasted sends. At scale (1M emails/month):

Without validation: $500/mo on email infrastructure for garbage
With validation: $50/mo API + clean list = 90% deliverability

Pricing

Plan	Price	Rate limit
BASIC	Free	50 req/hr
PRO	$9.99/mo	1,000 req/hr
ULTRA	$29.99/mo	10,000 req/hr

Try it

Email Validator Pro on RapidAPI

Free tier, no setup needed.

Built for SaaS signup forms where one email typo ruins the whole account recovery flow. This prevents that.

Domain WHOIS API: Get Registration, Expiry and Ownership Data in One Call

Alexey D — Tue, 05 May 2026 07:07:33 +0000

A domain's WHOIS data tells you everything: who owns it, when it was registered, when it expires, which nameservers it uses, and what registrar manages it.

Problem: Most WHOIS tools require manual lookups, and bulk WHOIS from traditional providers costs hundreds per month.

Domain WHOIS Lookup API does it in one call. REST endpoint, free tier, instant results.

What it does

POST /whois

Registrar name
Creation date
Expiration date
Updated date
Days until expiry
Status flags
Nameservers (up to 4)
Country
Organization
IP address (resolved)
Is expired? (boolean)

Use cases

Domain monitoring — track when your competitors' domains are about to expire
SEO audits — check nameserver config for domains you're auditing
Threat intel — identify newly registered domains from a registrar
Bulk domain validation — verify ownership before outreach
WHOIS scraping — avoid rate limits from manual WHOIS servers

Quick example

import requests

url = "https://domain-whois-lookup.p.rapidapi.com/whois"
headers = {
    "X-RapidAPI-Key": "YOUR_KEY",
    "Content-Type": "application/json"
}
payload = {"domain": "github.com"}

r = requests.post(url, json=payload, headers=headers)
print(r.json())

Response:

{
  "domain": "github.com",
  "registrar": "MarkMonitor, Inc.",
  "creation_date": "2007-10-09T18:20:50+00:00",
  "expiration_date": "2026-10-09T18:20:50+00:00",
  "updated_date": "2024-09-07T09:16:32+00:00",
  "days_until_expiry": 158,
  "status": ["clientDeleteProhibited", "clientTransferProhibited"],
  "name_servers": ["ns1.github.com", "ns2.github.com", "ns3.github.com"],
  "country": "US",
  "org": "GitHub, Inc.",
  "ip_address": "140.82.112.4",
  "is_expired": false
}

Real-world workflow

SEO agency scenario:

Get client's competitor list (50 domains)
Bulk WHOIS check: expiry dates, registrars, IP changes
Identify expiring domains → opportunities for acquisition
Track nameserver changes → detect migration before it goes live

Threat intel:

Monitor newly registered domains (WHOIS creation date < 7 days)
Cross-reference with your brand keywords
Flag suspicious lookalike domains early

Pricing

Plan	Price	Rate limit
BASIC	Free	50 req/hr
PRO	$9.99/mo	1,000 req/hr
ULTRA	$29.99/mo	10,000 req/hr

Try it

Domain WHOIS Lookup on RapidAPI

No credit card for free tier. Live in 30 seconds.

Built because WHOIS data is foundational for domain operations — why pay $0.50/lookup when you can get 50,000/month on a single subscription?

Validate Phone Numbers Worldwide With One API Call

Alexey D — Tue, 05 May 2026 07:02:21 +0000

Phone number validation is harder than it looks. Format varies by country, carriers differ, and you need to know timezone, line type (mobile vs fixed), and operator.

Most solutions require heavy dependencies or expensive APIs. I built Phone Validator Pro — a lightweight REST API that validates any number and returns all the metadata you need.

What it returns

POST /validate

{
  "phone": "+1-212-555-2000",
  "country_code": "US"
}

Response:

{
  "is_valid": true,
  "is_possible": true,
  "international_format": "+1 212-555-2000",
  "national_format": "(212) 555-2000",
  "e164_format": "+12125552000",
  "country_code": 1,
  "country": "United States",
  "carrier": "Verizon",
  "line_type": "FIXED_LINE_OR_MOBILE",
  "timezones": ["America/New_York", "America/Chicago", ...]
}

Quick start

Python

import requests

r = requests.post(
    "https://phone-validator-pro.p.rapidapi.com/validate",
    headers={"X-RapidAPI-Key": "YOUR_KEY"},
    json={"phone": "+79161234567", "country_code": "RU"}
)
print(r.json())

Batch validation

Check 50 numbers in one call:

phones = [
    {"phone": "+12125552000", "country_code": "US"},
    {"phone": "+442071838750", "country_code": "UK"},
    {"phone": "+33123456789", "country_code": "FR"}
]

r = requests.post(
    "https://phone-validator-pro.p.rapidapi.com/batch",
    headers={"X-RapidAPI-Key": "YOUR_KEY"},
    json=phones
)

Use cases

Lead validation — clean phone numbers before sales outreach
User signup — validate phone during registration
SMS campaigns — verify numbers before sending (prevent bounces)
Fraud detection — flag invalid or suspicious numbers
CRM enrichment — add carrier and timezone data to contacts
Global apps — validate numbers from 190+ countries

Pricing

Plan	Price	Limit
BASIC	Free	50 req/hr
PRO	$9.99/mo	1,000 req/hr
ULTRA	$29.99/mo	10,000 req/hr

Try it

Phone Validator Pro on RapidAPI

Built for lead validation workflows where phone numbers come from 20+ countries and formats vary wildly.

Feedback welcome.

Domain WHOIS API: Get Registration, Expiry and Ownership Data in One Call

Alexey D — Tue, 05 May 2026 07:01:51 +0000

Domain WHOIS data is essential for many workflows: checking domain expiry before renewal, detecting ownership changes, finding nameservers, or monitoring competitor domains.

Most WHOIS lookups require command-line tools, manual queries, or expensive services. I built Domain WHOIS Lookup API — a simple REST endpoint that returns structured WHOIS data for any domain.

What it returns

Single POST request gives you:

Registrar — who registered the domain
Creation date — when the domain was registered
Expiry date — when it expires (with days-until-expiry counter)
Updated date — last update timestamp
Nameservers — DNS servers pointing to domain's host
Country — registrant country
IP address — resolved IP of the domain
Status codes — registration status (locked, active, etc)
Organization — registrant organization name

Quick start

Python

import requests

url = "https://domain-whois-lookup.p.rapidapi.com/whois"
headers = {
    "X-RapidAPI-Key": "YOUR_KEY",
    "Content-Type": "application/json"
}
payload = {"domain": "github.com"}

r = requests.post(url, json=payload, headers=headers)
print(r.json())

Response:

{
  "domain": "github.com",
  "registrar": "MarkMonitor, Inc.",
  "creation_date": "2007-10-09T18:20:50+00:00",
  "expiration_date": "2026-10-09T18:20:50+00:00",
  "days_until_expiry": 158,
  "name_servers": ["ns-1234.awsdns-12.com", ...],
  "country": "US",
  "org": "GitHub, Inc.",
  "ip_address": "140.82.113.4",
  "is_expired": false
}

JavaScript

const response = await fetch("https://domain-whois-lookup.p.rapidapi.com/whois", {
  method: "POST",
  headers: {
    "X-RapidAPI-Key": "YOUR_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({ domain: "example.com" })
});
const data = await response.json();
console.log(`Domain expires in ${data.days_until_expiry} days`);

Use cases

Domain monitoring — track expiry dates for your portfolio
OSINT — research domain ownership and nameserver changes
Competitor analysis — monitor when competitors renew domains
Bulk audits — check 100s of domains for expiry or status changes
Infrastructure audits — verify nameserver configs automatically
Security — detect domain hijacking (sudden IP/nameserver changes)

Real example

Monitor your company domains and get alerted before expiry:

import requests
from datetime import datetime

domains = ["mycompany.com", "myproduct.io", "backup.net"]

for domain in domains:
    r = requests.post(url, json={"domain": domain}, headers=headers)
    data = r.json()

    if data["days_until_expiry"] < 30:
        print(f"⚠️ {domain} expires in {data['days_until_expiry']} days!")
    else:
        print(f"✓ {domain} - {data['days_until_expiry']} days remaining")

Pricing

Plan	Price	Rate limit
BASIC	Free	50 req/hr
PRO	$9.99/mo	1,000 req/hr
ULTRA	$29.99/mo	10,000 req/hr

Try it

Domain WHOIS Lookup on RapidAPI

Free tier, no credit card required. Perfect for domain portfolios, SEO agencies, and security teams.

Built this because checking WHOIS data was scattered across multiple tools and services. One API call covers everything.

Questions? Use cases? Let me know in the comments.