DEV Community: Alexey D

Self-Hosted Audio Transcription API with Whisper — Free, No Limits, No Black Box

Alexey D — Wed, 01 Jul 2026 08:38:00 +0000

Most transcription services are a black box. You send audio, you get text, you pay per minute, and you have no idea what's happening on the other side. When the language is wrong, the timestamps are off, or the accent throws it off — you file a support ticket and wait.

There's a better way. OpenAI's Whisper model is open-source, runs on CPU, and produces results that match or beat commercial services for most use cases. The catch is that setting it up in production — with a proper API, format handling, error management, and language detection — takes time that most projects don't have.

I've already done that. Here's how to use it.

What the API does

Single endpoint, straightforward contract:

curl -X POST https://sofa-rarely-mailing-buzz.trycloudflare.com/transcribe \
  -F "audio=@meeting_recording.mp3" \
  -F "language=en"

Response:

{
  "text": "Alright, let's get started. First item on the agenda is the Q3 budget review.",
  "language": "en",
  "language_name": "English",
  "duration": 47.3,
  "segments": [
    {
      "id": 0,
      "start": 0.0,
      "end": 3.2,
      "text": "Alright, let's get started."
    },
    {
      "id": 1,
      "start": 3.2,
      "end": 7.8,
      "text": "First item on the agenda is the Q3 budget review."
    }
  ],
  "model": "whisper-tiny",
  "processing_time": 8.4
}

The segments array with timestamps is what makes this useful for real applications — subtitle generation, searchable transcripts, meeting summarization by section.

Supported formats

MP3, WAV, OGG, M4A, WEBM, FLAC, MP4. Up to 25MB per file. If your file is larger, split it first — ffmpeg -i input.mp3 -f segment -segment_time 300 -c copy part%03d.mp3.

Python — transcribe and search

import requests

def transcribe(file_path: str, language: str = None) -> dict:
    with open(file_path, 'rb') as f:
        data = {"audio": f}
        if language:
            data["language"] = (None, language)
        r = requests.post(
            "https://sofa-rarely-mailing-buzz.trycloudflare.com/transcribe",
            files={"audio": f},
            data={"language": language} if language else {},
            timeout=120
        )
    r.raise_for_status()
    return r.json()

result = transcribe("interview.mp3")

# Full transcript
print(result["text"])

# Find specific moments
keyword = "budget"
matches = [
    seg for seg in result["segments"]
    if keyword.lower() in seg["text"].lower()
]

for m in matches:
    print(f"[{m['start']:.1f}s] {m['text']}")

Auto-translate to English

The task parameter accepts "translate" — it transcribes AND translates to English in one call. No separate translation step needed.

r = requests.post(
    "https://sofa-rarely-mailing-buzz.trycloudflare.com/transcribe",
    files={"audio": open("german_podcast.mp3", "rb")},
    data={"task": "translate"}
)

result = r.json()
print(result["language"])  # "de"
print(result["text"])      # English translation

This works across all 39 supported languages. The model detects the source language automatically when you don't specify one.

Language auto-detection

Skip the language parameter and Whisper figures it out:

result = transcribe("unknown_language_audio.ogg")
print(result["language"])      # "fr"
print(result["language_name"]) # "French"

Detection accuracy drops on very short clips (under 10 seconds) and heavily accented speech. For production, if you know the language, pass it explicitly — it's faster and more accurate.

JavaScript — browser upload

async function transcribeFile(file) {
  const formData = new FormData();
  formData.append('audio', file);
  // optionally: formData.append('language', 'en');

  const res = await fetch('https://sofa-rarely-mailing-buzz.trycloudflare.com/transcribe', {
    method: 'POST',
    body: formData
  });

  if (!res.ok) throw new Error(`Transcription failed: ${res.status}`);
  return res.json();
}

// In your file input handler:
fileInput.addEventListener('change', async (e) => {
  const file = e.target.files[0];
  if (!file) return;

  statusEl.textContent = 'Transcribing...';
  const result = await transcribeFile(file);
  transcriptEl.textContent = result.text;
  statusEl.textContent = `Done (${result.duration.toFixed(1)}s audio, ${result.processing_time.toFixed(1)}s processing)`;
});

Processing time expectations

The API runs Whisper tiny on CPU. Rough benchmarks:

Audio length	Processing time
30 seconds	3–6 seconds
2 minutes	12–20 seconds
5 minutes	30–50 seconds
10 minutes	60–90 seconds

For a meeting transcription workflow this is fine. For real-time voice-to-text it's not — that needs a streaming setup with a larger server.

What it doesn't handle well

Heavy accents + background noise is the hardest case for the tiny model. If you're transcribing call center recordings with noisy environments, accuracy will be lower than a commercial service using a larger model.

Speaker diarization (who said what) is not included. The output is continuous text with timestamps, not labeled by speaker. Adding diarization requires an additional processing step with something like pyannote.audio.

Timestamps are approximate on short segments. The segmentation algorithm sometimes splits sentences in odd places for fast speakers.

Available on RapidAPI

The stable version with rate limits and API keys is listed on RapidAPI — search "Audio Transcription Whisper." Free tier included.

GET /languages returns the full list of 39 supported languages with ISO codes if you need to build a language selector.

Detecting Text Language in Production — What the Libraries Don't Tell You

Alexey D — Wed, 01 Jul 2026 08:34:33 +0000

langdetect, langid, fasttext — all fine libraries. All have the same problem: they fail on short text, mixed-language input, and transliterated text. When your user submits a 6-word product review or a support ticket written half in English and half in their native language, accuracy drops fast.

There's also the question of what you do with the detection result. Routing support tickets to the right team, serving the right content, auto-tagging user-generated content — these need a reliable signal, not a guess with no confidence metric.

What production language detection actually needs

Confidence score — "I'm 94% sure this is Russian" is useful. "It's Russian" with no probability is not.
Script detection — Latin, Cyrillic, Arabic, CJK, Devanagari. Sometimes you need the script, not the language. A Russian text in Latin transliteration is still Russian content.
Dialect hints — Portuguese from Brazil vs Portugal, Chinese Simplified vs Traditional, American vs British English.
Reliability flag — when the text is too short or too ambiguous, you need to know that, not get a confident wrong answer.
Batch processing — running per-text HTTP calls at scale is wasteful.

The API

curl -X POST https://protection-meeting-what-elvis.trycloudflare.com/detect \
  -H "Content-Type: application/json" \
  -d '{"text": "Не могу войти в аккаунт, помогите пожалуйста"}'

Response:

{
  "language": "ru",
  "language_name": "Russian",
  "confidence": 0.97,
  "script": "Cyrillic",
  "dialect_hint": null,
  "reliability": "high",
  "alternatives": [
    {"language": "uk", "language_name": "Ukrainian", "confidence": 0.02},
    {"language": "bg", "language_name": "Bulgarian", "confidence": 0.01}
  ]
}

reliability is high when confidence is above 90%, medium for 70–90%, low below that. For routing and tagging workflows, I'd suggest only acting on high and medium — queue low for human review or fallback logic.

Python — routing support tickets

import requests

def detect_language(text: str) -> dict:
    r = requests.post(
        "https://protection-meeting-what-elvis.trycloudflare.com/detect",
        json={"text": text},
        timeout=5
    )
    r.raise_for_status()
    return r.json()

def route_ticket(ticket_text: str, ticket_id: str):
    result = detect_language(ticket_text)

    lang = result["language"]
    confidence = result["confidence"]
    reliability = result["reliability"]

    if reliability == "low":
        assign_to_queue("multilingual-review", ticket_id)
        return

    routing_map = {
        "en": "support-en",
        "de": "support-de",
        "fr": "support-fr",
        "es": "support-es",
        "ru": "support-ru",
        "zh": "support-zh",
    }

    queue = routing_map.get(lang, "support-general")
    assign_to_queue(queue, ticket_id, metadata={
        "detected_lang": lang,
        "confidence": confidence,
        "script": result["script"]
    })

Batch processing

Doing one HTTP call per document is wasteful. The batch endpoint takes up to 20 texts:

import requests

texts = [
    "Hello, I need help with my order",
    "Bonjour, j'ai un problème avec ma commande",
    "Здравствуйте, у меня проблема с заказом",
    "こんにちは、注文に問題があります",
    "مرحبا، لدي مشكلة في طلبي",
]

r = requests.post(
    "https://protection-meeting-what-elvis.trycloudflare.com/batch",
    json={"texts": texts}
)

for item in r.json()["results"]:
    print(f"{item['language_name']:15} ({item['confidence']:.0%}) [{item['script']}] — {item['reliability']}")

Output:

English         (99%) [Latin]    — high
French          (98%) [Latin]    — high
Russian         (97%) [Cyrillic] — high
Japanese        (99%) [CJK]      — high
Arabic          (98%) [Arabic]   — high

Script vs Language — when you need the script

Sometimes you don't care which Slavic language it is — you just need to know if the text is in Cyrillic so you can load the right font, keyboard layout, or content policy.

result = detect_language(user_bio)

if result["script"] == "Arabic":
    enable_rtl_layout()
elif result["script"] in ("CJK", "Hiragana", "Katakana"):
    enable_cjk_typography()

Supported scripts: Latin, Cyrillic, Arabic, CJK (Chinese/Japanese/Korean), Devanagari, Hebrew, Greek, Thai, Georgian, Armenian, and others.

Dialect hints

result = detect_language("I was queueing outside the colour shop")
# {"language": "en", "dialect_hint": "en-GB", "confidence": 0.89}

result = detect_language("Eu moro em São Paulo há cinco anos")
# {"language": "pt", "dialect_hint": "pt-BR", "confidence": 0.94}

This is useful for content localization — even when the language is the same, en-US and en-GB users expect different date formats, spelling, and sometimes terminology.

What it doesn't do well

Short text under 10–15 characters is genuinely hard. "OK", "Thanks", "Hola" — these are ambiguous by nature. The API will still return a result, but reliability will be low. Plan for that in your logic.

Mixed-language text (code-switching like "Привет, let me знаешь explain this") is also tricky — the API picks the dominant language, not both. If you need mixed-language detection, the alternatives array helps, but this isn't a use case the API optimizes for.

Languages supported

55+ languages. Full list: GET /languages endpoint returns the complete map with ISO codes.

Common ones: English, Russian, German, French, Spanish, Italian, Portuguese, Dutch, Polish, Turkish, Arabic, Chinese (Simplified/Traditional), Japanese, Korean, Ukrainian, Hindi, Persian, Swedish, Danish, Finnish, Norwegian, Czech, Romanian, Hungarian, and more.

Try it

Free tier on RapidAPI — search "Language Detection API." Test endpoint works without authentication.

Why Your Email Validation is Probably Wrong (And How to Fix It)

Alexey D — Wed, 01 Jul 2026 08:33:50 +0000

Most apps validate email with a regex. Some add an MX record check. Both are necessary — neither is sufficient.

Here's what you're missing: an email address can be syntactically valid, have proper MX records, and still be completely useless. It might be a disposable inbox that expires in 10 minutes, a catch-all address that accepts everything but nobody reads, or admin@yourcompany.com — a role account that goes to a shared inbox and gets marked as spam on arrival.

The gap between "this address exists" and "a real person will read this email" is where deliverability problems live.

The real validation checklist

Syntax — RFC 5322 compliant, not just regex
MX records — does the domain actually receive email?
Disposable detection — is this from a throwaway service?
Catch-all detection — does the domain accept everything regardless?
Role account detection — is this info@, noreply@, admin@?
Deliverability score — given all the above, will this email actually reach someone?

The API

I built an email validation API that checks all six. Free tier available.

curl -X POST https://cardiac-nickel-eat-whether.trycloudflare.com/validate \
  -H "Content-Type: application/json" \
  -d '{"email": "test@gmail.com"}'

Response:

{
  "email": "test@gmail.com",
  "is_valid": true,
  "is_disposable": false,
  "is_role_based": false,
  "is_catch_all": false,
  "is_premium_provider": true,
  "mx_valid": true,
  "deliverability_score": 94,
  "quality": "excellent",
  "domain": "gmail.com",
  "suggestion": null
}

The deliverability_score (0–100) is the number you actually care about. quality maps it to a human label: excellent (85+), good (60–84), risky (30–59), invalid (below 30).

Python integration

import requests

def check_email(email: str) -> dict:
    r = requests.post(
        "https://cardiac-nickel-eat-whether.trycloudflare.com/validate",
        json={"email": email},
        timeout=5
    )
    r.raise_for_status()
    return r.json()

def should_accept_signup(email: str) -> tuple[bool, str]:
    result = check_email(email)

    if not result["is_valid"] or not result["mx_valid"]:
        return False, "Email address doesn't exist"

    if result["is_disposable"]:
        return False, "Disposable email addresses are not allowed"

    if result["deliverability_score"] < 30:
        return False, "We couldn't verify this email address"

    # Risky but not blocked — you might want to require email confirmation
    if result["deliverability_score"] < 60:
        return True, "low_confidence"  # flag for stricter onboarding

    return True, "ok"

Batch cleaning for existing lists

If you're working with an existing user base or imported leads:

import requests

emails = [
    "user@gmail.com",
    "test123@mailinator.com",  # disposable
    "info@somecompany.com",    # role-based
    "anything@catch-all.io",  # catch-all
]

r = requests.post(
    "https://cardiac-nickel-eat-whether.trycloudflare.com/batch",
    json={"emails": emails}
)

results = r.json()["results"]

sendable = [
    r["email"] for r in results
    if r["deliverability_score"] >= 60 and not r["is_role_based"]
]

print(f"Sendable: {len(sendable)}/{len(emails)}")
# Sendable: 1/4

Up to 10 emails per batch request.

JavaScript — real-time form validation

const validateEmail = async (email) => {
  const res = await fetch('https://cardiac-nickel-eat-whether.trycloudflare.com/validate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ email })
  });
  return res.json();
};

// Debounced input handler
let timer;
emailInput.addEventListener('input', () => {
  clearTimeout(timer);
  timer = setTimeout(async () => {
    const result = await validateEmail(emailInput.value);

    if (result.is_disposable) {
      showError('Please use a permanent email address');
    } else if (result.suggestion) {
      showHint(`Did you mean ${result.suggestion}?`);
    } else if (result.quality === 'excellent' || result.quality === 'good') {
      showSuccess();
    }
  }, 600);
});

Note the suggestion field — if someone types user@gmial.com, the API returns "suggestion": "user@gmail.com". Typo correction in a single API call.

What "catch-all" means and why it matters

A catch-all domain accepts every email sent to it — anything@example.com, doesnotexist@example.com, all of it — and the MX record check passes. This fools naive validators completely.

The problem: you have no idea if a real person owns john@catch-all-company.com. It might be the CEO's inbox. It might route to /dev/null.

The API flags these with "is_catch_all": true and drops the deliverability score accordingly. You can choose how to handle them — maybe allow but require confirmation, maybe just log and monitor bounce rates.

Disposable email coverage

The API checks against 300+ known disposable email providers: Mailinator, Guerrilla Mail, 10 Minute Mail, Temp Mail, and hundreds more. The list is updated regularly.

If you find a disposable service that slips through, I'm open to adding it — leave a comment with the domain.

Try it

Free tier on RapidAPI — search "Email Validator Pro." The test endpoint above works without authentication for evaluation.

Phone Number Validation is Harder Than You Think (Here's a Free API That Gets It Right)

Alexey D — Wed, 01 Jul 2026 08:33:50 +0000

You'd think validating a phone number is trivial. Regex, right? Something like ^\+?[0-9]{7,15}$ and you're done.

Then your users start entering numbers like +1 (800) 555‑0199, 07911 123456, +49 (0) 30 1234567, or just 8 800 555 35 35. Your regex passes all of them. Your SMS provider rejects half.

The real problem isn't format — it's that phone number rules are different in every country, change when telecoms merge, and a valid-looking number can still be a VoIP burner that will never receive an SMS.

What actually needs checking

When you validate a phone number for real-world use, you need:

E.164 normalization — the standard format carriers use (+79001234567, not 8 900 123-45-67)
Line type — mobile, landline, VoIP, toll-free, premium-rate. Sending OTPs to a landline is a UX dead-end.
Carrier lookup — not always necessary, but useful for fraud detection
Geographic data — country, region, timezone offset
Fraud signal — VoIP numbers and certain number ranges are disproportionately used for fake signups

Doing this with a library like libphonenumber covers the first two. The rest requires live data.

The API

I've been running a phone validation API that wraps all of this into one call. It's free to try.

Endpoint: POST /validate

curl -X POST https://wesley-twiki-athletics-comment.trycloudflare.com/validate \
  -H "Content-Type: application/json" \
  -d '{"phone": "+79001234567"}'

Response:

{
  "phone": "+79001234567",
  "is_valid": true,
  "formatted": "+7 900 123-45-67",
  "country": "Russia",
  "country_code": "RU",
  "carrier": "MegaFon",
  "line_type": "mobile",
  "timezones": ["Europe/Moscow"],
  "fraud_risk": {
    "score": 12,
    "risk_level": "low"
  },
  "is_voip": false,
  "flags": {
    "voip_number": false,
    "premium_rate": false,
    "invalid_number": false,
    "personal_number": false
  }
}

The fraud_risk.score is 0–100. Anything above 60 is worth a second look — it means the number shares characteristics (VoIP range, recently allocated block, carrier pattern) with numbers commonly used for fake accounts.

Using it in Python

import requests

def validate_phone(phone: str) -> dict:
    r = requests.post(
        "https://wesley-twiki-athletics-comment.trycloudflare.com/validate",
        json={"phone": phone},
        timeout=5
    )
    r.raise_for_status()
    return r.json()

result = validate_phone("+447911123456")

if not result["is_valid"]:
    raise ValueError("Invalid phone number")

if result["is_voip"]:
    # maybe ask for verification, don't block outright
    flag_for_review(result)

if result["fraud_risk"]["score"] > 70:
    require_additional_verification(result)

Batch validation

If you're cleaning a database or processing signups in bulk, there's a batch endpoint:

import requests

numbers = [
    "+79001234567",
    "+447911123456",
    "+12025551234",
    "+49301234567"
]

r = requests.post(
    "https://wesley-twiki-athletics-comment.trycloudflare.com/batch",
    json={"phones": numbers}
)

results = r.json()["results"]
valid = [r for r in results if r["is_valid"]]
voip  = [r for r in results if r["is_voip"]]

print(f"{len(valid)}/{len(numbers)} valid, {len(voip)} VoIP")

Up to 10 numbers per request.

In JavaScript (for signup forms)

async function validatePhone(phone) {
  const res = await fetch('https://wesley-twiki-athletics-comment.trycloudflare.com/validate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ phone })
  });

  if (!res.ok) throw new Error('Validation failed');
  return res.json();
}

// In your form handler:
const result = await validatePhone(formData.phone);

if (!result.is_valid) {
  showError('Please enter a valid phone number');
} else if (result.is_voip && result.fraud_risk.score > 50) {
  showWarning('We may need to verify this number');
}

When fraud_risk matters

A score above 50 doesn't mean "block the user." It means "this number looks like it came from a number pool rather than a person's SIM card." What you do with that is up to your risk tolerance:

Score 0–30: Normal. Proceed.
Score 30–60: Worth logging. Consider a CAPTCHA or email backup.
Score 60–80: High probability of VoIP or bulk-registered number. Add a verification step.
Score 80–100: Almost certainly a burner or auto-generated number. Block or require alternative verification.

Try it

The API is available on RapidAPI with a free tier if you need a stable key and rate limits for production. The endpoint above is for testing.

RapidAPI listing: search "Phone Validator Pro" — or drop a comment and I'll link it directly.

Works with 240+ country codes. Returns in under 200ms for most requests.

Detect Text Language in Python — Free API, 55 Languages & Confidence Score

Alexey D — Fri, 08 May 2026 09:09:10 +0000

How to Detect Text Language in Python — 55 Languages, Free API

Language detection sounds simple until you try to build it yourself. Rule-based heuristics fail on short text. Running a full NLP model on your server is overkill for a lookup operation. And most free libraries top out at 20–30 languages.

This tutorial shows how to detect the language of any text in Python and JavaScript using a free API that supports 55+ languages and returns a confidence score so you can decide what to do with low-confidence results.

The API: Language Detector Pro

👉 Language Detector Pro on RapidAPI

55+ languages detected
Confidence score (0.0 – 1.0)
ISO 639-1 language codes
Works on short strings (tweets, user inputs, form fields)
Batch detection endpoint

Sample Response

\json { \"text\": \"Bonjour le monde\", \"language\": \"French\", \"language_code\": \"fr\", \"confidence\": 0.98 } \\

Python Example

\`python
import requests

def detect_language(text):
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\": text}, headers=headers)
data = r.json()
return {
\"language\": data[\"language\"],
\"code\": data[\"language_code\"],
\"confidence\": data[\"confidence\"]
}

print(detect_language(\"Bonjour le monde\"))

{\"language\": \"French\", \"code\": \"fr\", \"confidence\": 0.98}

print(detect_language(\"Привет мир\"))

{\"language\": \"Russian\", \"code\": \"ru\", \"confidence\": 0.99}

print(detect_language(\"こんにちは世界\"))

{\"language\": \"Japanese\", \"code\": \"ja\", \"confidence\": 0.97}

`\

JavaScript Example

\javascript async function detectLanguage(text) { 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 }) }); const data = await res.json(); console.log(\\${data.language} (\${data.language_code}) — confidence: \${data.confidence}`);
return data;
}

detectLanguage(\"Hola mundo\");
// Spanish (es) — confidence: 0.99
`\

Batch Detection

\`python
texts = [\"Bonjour le monde\", \"Привет мир\", \"Hello world\", \"مرحبا بالعالم\"]

r = requests.post(
\"https://language-detector-pro.p.rapidapi.com/batch\",
json={\"texts\": texts},
headers={\"X-RapidAPI-Key\": \"YOUR_KEY\", \"Content-Type\": \"application/json\"}
)

for item in r.json():
print(f\"{item['language_code']}: {item['text'][:30]:<30} conf:{item['confidence']:.2f}\")
`\

Supported Languages (55+)

English, Spanish, French, German, Italian, Portuguese, Russian, Arabic, Chinese, Japanese, Korean, Dutch, Polish, Turkish, Swedish, Norwegian, Danish, Finnish, Hebrew, Hindi, Bengali, Vietnamese, Thai, Indonesian, and more.

Practical Use Cases

Content moderation — route text to the right language moderator
User onboarding — auto-detect locale and switch UI language
Support tickets — auto-assign to agents by language
Search engines — apply the right stemmer per language

Free Tier

Free tier available — no credit card required.

👉 Subscribe here: Language Detector Pro on RapidAPI

Also check out: Phone Validator Pro | Email Validator Pro

How to Detect Text Language in Python — 55 Languages, Free API

Alexey D — Fri, 08 May 2026 09:08:42 +0000

How to Detect Text Language in Python — 55 Languages, Free API

Building a multilingual app? Routing support tickets? Filtering content by region? You need to know what language a text is written in — fast and reliably.

This guide shows how to detect text language in Python and JavaScript using a free API that supports 55+ languages and returns a confidence score.

The API: Language Detector Pro

👉 Language Detector Pro on RapidAPI

55+ languages including Arabic, Chinese, Japanese, Korean, Hindi
Confidence score (0.0–1.0)
Short text support (works on 10+ characters)
Batch endpoint (up to 20 texts per request)

Sample Response

{
  "language": "ru",
  "language_name": "Russian",
  "confidence": 0.97,
  "alternatives": [
    {"language": "uk", "confidence": 0.02},
    {"language": "bg", "confidence": 0.01}
  ]
}

Python Example

import requests

def detect_language(text):
    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": text}, headers=headers)
    data = r.json()

    return {
        "language": data["language_name"],
        "code": data["language"],
        "confidence": data["confidence"]
    }

# Usage
texts = [
    "Hello, how are you?",
    "Привет, как дела?",
    "Bonjour, comment allez-vous?",
    "こんにちは、お元気ですか？",
    "مرحبا، كيف حالك؟"
]

for text in texts:
    result = detect_language(text)
    print(f"{result['language']:<12} ({result['code']}) | confidence: {result['confidence']:.0%}")

Output:

English      (en) | confidence: 99%
Russian      (ru) | confidence: 97%
French       (fr) | confidence: 98%
Japanese     (ja) | confidence: 99%
Arabic       (ar) | confidence: 99%

JavaScript Example

async function detectLanguage(text) {
  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 })
  });

  const data = await res.json();
  console.log(`${data.language_name} (${data.language}) — ${(data.confidence * 100).toFixed(1)}%`);
  return data;
}

detectLanguage("Eu falo português");
// Portuguese (pt) — 96.3%

detectLanguage("Ich spreche Deutsch");
// German (de) — 98.7%

Batch Detection

Detect language for up to 20 texts at once — perfect for routing support tickets:

import requests

tickets = [
    "My order hasn't arrived",
    "Mi pedido no ha llegado",
    "Meine Bestellung ist nicht angekommen",
    "我的订单还没有到达"
]

r = requests.post(
    "https://language-detector-pro.p.rapidapi.com/batch",
    json={"texts": tickets},
    headers={"X-RapidAPI-Key": "YOUR_KEY", "Content-Type": "application/json"}
)

for i, item in enumerate(r.json()):
    print(f"[{i}] {item['language_name']:<12} → route to {item['language'].upper()} support team")

Output:

[0] English      → route to EN support team
[1] Spanish      → route to ES support team
[2] German       → route to DE support team
[3] Chinese      → route to ZH support team

Real-World Use Cases

Support routing — automatically assign tickets to the right language team
Content moderation — filter content by language/region
Chatbots — detect language before responding
Translation pipelines — route text to the correct translation service
SEO analysis — identify language of scraped content

Free Tier

Free tier available — no credit card required.

👉 Subscribe here: Language Detector Pro on RapidAPI

Also check out: Phone Validator Pro | Email Validator Pro

How to Validate Email Addresses in JavaScript — Deliverability Score API

Alexey D — Fri, 08 May 2026 09:08:16 +0000

How to Validate Email Addresses in JavaScript — Deliverability Score API

Regex will not save you. You can validate email format perfectly and still end up with a list full of disposable addresses, catch-all domains, and role-based inboxes that kill your sender reputation.

This guide shows how to do real email validation in JavaScript and Python using a free API that checks MX records, disposable domains, and returns a quality score (0–100).

The API: Email Validator Pro

👉 Email Validator Pro on RapidAPI

MX record lookup (does the domain actually receive mail?)
300+ disposable domain blocklist (mailinator, guerrilla, etc.)
Role-based address detection (admin@, info@, noreply@)
Catch-all domain detection
Quality score 0–100
Batch endpoint (up to 50 emails)

Sample Response

{
  "email": "test@gmail.com",
  "is_valid": true,
  "mx_valid": true,
  "is_disposable": false,
  "is_role_based": false,
  "quality_score": 95,
  "domain": "gmail.com"
}

JavaScript Example

async function validateEmail(email) {
  const res = await fetch("https://emailvalidatorpro.p.rapidapi.com/validate", {
    method: "POST",
    headers: {
      "X-RapidAPI-Key": "YOUR_KEY",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({ email })
  });

  const data = await res.json();

  if (!data.is_valid || data.is_disposable) {
    console.log("Rejected:", email);
    return false;
  }

  console.log(`Score: ${data.quality_score}/100 | MX: ${data.mx_valid}`);
  return true;
}

// Examples
validateEmail("user@gmail.com");      // Score: 95/100 | MX: true
validateEmail("fake@mailinator.com"); // Rejected: fake@mailinator.com
validateEmail("info@company.com");    // Role-based — handle accordingly

Python Example

import requests

def validate_email(email):
    url = "https://emailvalidatorpro.p.rapidapi.com/validate"
    headers = {
        "X-RapidAPI-Key": "YOUR_KEY",
        "Content-Type": "application/json"
    }
    r = requests.post(url, json={"email": email}, headers=headers)
    data = r.json()

    return {
        "valid": data["is_valid"],
        "mx": data["mx_valid"],
        "disposable": data["is_disposable"],
        "role_based": data["is_role_based"],
        "score": data["quality_score"]
    }

# Usage
print(validate_email("test@gmail.com"))
# {"valid": True, "mx": True, "disposable": False, "role_based": False, "score": 95}

print(validate_email("user@mailinator.com"))
# {"valid": True, "mx": True, "disposable": True, "role_based": False, "score": 5}

Batch Validation

import requests

emails = [
    "user@gmail.com",
    "fake@mailinator.com",
    "info@company.com",
    "bad@nonexistent-domain-xyz.com"
]

r = requests.post(
    "https://emailvalidatorpro.p.rapidapi.com/batch",
    json={"emails": emails},
    headers={"X-RapidAPI-Key": "YOUR_KEY", "Content-Type": "application/json"}
)

for item in r.json():
    status = "✓" if item["is_valid"] and not item["is_disposable"] else "✗"
    print(f"{status} {item['email']:<30} score:{item['quality_score']}")

When to Block vs Warn

Condition	Action
`is_valid: false`	Block always
`mx_valid: false`	Block — email can't be delivered
`is_disposable: true`	Block on sign-up
`is_role_based: true`	Warn user or flag for review
`quality_score < 40`	Ask user to double-check

Free Tier

Free tier available — no credit card needed.

👉 Subscribe here: Email Validator Pro on RapidAPI

Also check out: Phone Validator Pro | Language Detector Pro

How to Validate Phone Numbers in Python — Free API with Fraud Risk Scoring

Alexey D — Fri, 08 May 2026 09:07:53 +0000

How to Validate Phone Numbers in Python — Free API with Fraud Risk Scoring

Every app that collects phone numbers faces the same problem: users enter junk. Typos, fake numbers, VoIP burners, numbers from the wrong country — you only find out when your SMS campaign bounces or a fraudster slips through.

This tutorial shows how to validate phone numbers in Python and JavaScript using a free API that returns not just validity — but carrier info, line type, and a fraud risk score.

The API: Phone Validator Pro

👉 Phone Validator Pro on RapidAPI

240+ countries
Line type detection: MOBILE / LANDLINE / VOIP / TOLL_FREE
Carrier identification
Timezone info
Batch endpoint (up to 50 numbers)

Sample Response

{
  "is_valid": true,
  "international_format": "+1 212-555-2000",
  "e164_format": "+12125552000",
  "country": "United States",
  "carrier": "AT&T",
  "line_type": "MOBILE",
  "timezones": ["America/New_York"]
}

Python Example

import requests

def validate_phone(phone, country_code="US"):
    url = "https://phonevalidatorpro.p.rapidapi.com/validate"
    headers = {
        "X-RapidAPI-Key": "YOUR_KEY",
        "Content-Type": "application/json"
    }
    r = requests.post(url, json={"phone": phone, "country_code": country_code}, headers=headers)
    data = r.json()

    if not data["is_valid"]:
        return {"valid": False}

    return {
        "valid": True,
        "country": data["country"],
        "carrier": data["carrier"],
        "line_type": data["line_type"],
        "e164": data["e164_format"]
    }

# Usage
print(validate_phone("+79161234567", "RU"))
# {"valid": True, "country": "Russia", "carrier": "MTS", "line_type": "MOBILE", "e164": "+79161234567"}

print(validate_phone("+12125552000", "US"))
# {"valid": True, "country": "United States", "carrier": "AT&T", "line_type": "MOBILE", ...}

JavaScript Example

async function validatePhone(phone, countryCode = "US") {
  const res = await fetch("https://phonevalidatorpro.p.rapidapi.com/validate", {
    method: "POST",
    headers: {
      "X-RapidAPI-Key": "YOUR_KEY",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({ phone, country_code: countryCode })
  });

  const data = await res.json();

  if (!data.is_valid) {
    console.log("Invalid number");
    return null;
  }

  console.log(`${data.country} | ${data.carrier} | ${data.line_type}`);
  return data;
}

validatePhone("+447911123456", "GB");
// United Kingdom | EE | MOBILE

Batch Validation

Validate up to 50 numbers in one request:

import requests

numbers = [
    {"phone": "+79161234567", "country_code": "RU"},
    {"phone": "+447911123456", "country_code": "GB"},
    {"phone": "+12125552000", "country_code": "US"}
]

r = requests.post(
    "https://phonevalidatorpro.p.rapidapi.com/batch",
    json=numbers,
    headers={"X-RapidAPI-Key": "YOUR_KEY", "Content-Type": "application/json"}
)

for item in r.json():
    status = "✓" if item["is_valid"] else "✗"
    print(f"{status} {item.get('e164_format', item.get('phone'))} | {item.get('line_type', 'N/A')}")

Practical Use Cases

Sign-up forms — block invalid numbers before sending OTP
CRM cleanup — batch-validate your contact database
SMS campaigns — filter out landlines and VoIP
Fraud prevention — flag VOIP numbers at registration

Free Tier

Free tier is available — no credit card required.

👉 Subscribe here: Phone Validator Pro on RapidAPI

Also check out my other APIs: Email Validator Pro | Language Detector Pro

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 — 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.

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.