Check if a phone number is registered on Telegram

The Telegram check tells you whether a phone number has a Telegram account. You get registered: true, false or null (unknown) with the time of the check, in real time or in a bulk job, for numbers from any country. The check sends nothing to the number and returns no username, name or photo.

#What does the Telegram check tell you?

It answers whether a Telegram account is associated with the phone number. Telegram asks for a phone number when someone signs up and confirms it with a code, so every account starts from a number. After that, Telegram is built around usernames: people can chat without ever sharing their number, and the privacy settings let them choose who can see their number and who can find them by it.

That design matters for how you read the answer:

• registered: true: an account is associated with the number and could be found.
• registered: false: a conclusive answer that no account was found for the number.
• registered: null: we could not get a conclusive answer. status and reason explain why, and you are not charged.

Because discoverability is under the account holder's control, a false on Telegram is a weaker "no" than on a platform where every account can be found by number. Treat it as "not reachable by this number", which is usually what a channel decision needs.

#Who uses it, and why?

Telegram's founder announced in March 2025 that the app had passed one billion monthly active users. Its use is uneven: it is a main messenger in parts of Eastern Europe, Central Asia and the Middle East, and a secondary app in many markets where WhatsApp leads.

• Verification codes. Telegram offers a paid gateway that lets businesses deliver verification codes to users inside Telegram. Teams that use it check registration first, so codes go to Telegram only when the number has an account and the rest go to SMS.
• Channel selection. Support and notification teams in Telegram-heavy markets check whether a customer who opted in can be reached there. See channel selection.
• Sign-up screening. A new sign-up whose number has neither Telegram nor WhatsApp nor Viber is not necessarily fake, but it gives fraud rules a data point. Combine it with a carrier lookup.

#What do you get back?

One result per number in checks["telegram.registered"]. The service has no extra attributes.

#How is it billed?

You pay per number checked, only for conclusive answers. You're not charged for inconclusive results (unknown, unsupported country, timeout, invalid, duplicate). Real-time and bulk checks are priced separately; bulk is cheaper when the answer can wait. See pricing.

A repeat check of the same number within the freshness window can come from your account's cache at no charge (cached: true, billed: false). max_age: 0 forces a fresh check, which is billed. max_cost stops a request that could cost more than you set.

#What are the limits?

Telegram is available in real time (POST /v1/lookup, 1–100 numbers, waits up to 30 seconds, default 10) and in bulk jobs (POST /v1/jobs, up to 50,000 numbers and e-mails). There are no country restrictions.

• Up to 20 checks per request; numbers × checks capped at 2,000 per lookup and 100,000 per job.
• Requests that look like sequential number ranges or generated e-mail lists are rejected with suspected_enumeration.
• A daily number cap applies per account (GET /v1/limits).
• Unknown answers mostly come from timeouts. Privacy settings can also make an account impossible to find by number.

#How do I use it responsibly?

Check the numbers of people who gave them to you and agreed to be contacted, and use the answer to pick a channel they expect. Telegram's reach through public groups and channels makes it attractive for spam, and our acceptable use policy forbids using checks to find people to message unsolicited or to work out who is on Telegram by scanning number ranges. Respect the fact that many Telegram users hide their number on purpose. People can object to checks through the opt-out form.

#Example request

With a test key, +447700900001 answers "registered", +447700900002 "not registered" and +447700900003 "unknown". See test mode.

curl https://api.mobilevalidate.com/v1/lookup \
  -H "Authorization: Bearer mv_test_publicSandboxn9ZgneuhR1B9CRfKG3fulym" \
  -H "Content-Type: application/json" \
  -d '{"numbers":["+447700900001"],"checks":["telegram"]}'

// npm install mobilevalidate · Node.js 20+ · save as check.mjs and run: node check.mjs
import { MobileValidate } from "mobilevalidate";

// Omit apiKey to read MOBILEVALIDATE_API_KEY from the environment.
const mv = new MobileValidate({ apiKey: "mv_test_publicSandboxn9ZgneuhR1B9CRfKG3fulym" });
const { data, error } = await mv.lookup({
  numbers: ["+447700900001"],
  checks: ["telegram"],
});
if (error) console.error(error.code, error.message);
else console.dir(data.results, { depth: null });

// Node.js 18+, Deno, Bun or the browser console (ES module: save as .mjs or use "type": "module").
const res = await fetch("https://api.mobilevalidate.com/v1/lookup", {
  method: "POST",
  headers: {
    Authorization: "Bearer mv_test_publicSandboxn9ZgneuhR1B9CRfKG3fulym",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    numbers: ["+447700900001"],
    checks: ["telegram"],
  }),
});
console.log(res.status, res.headers.get("x-request-id"));
console.dir(await res.json(), { depth: null });

# pip install mobilevalidate-sdk
from mobilevalidate import MobileValidate

# Omit api_key to read MOBILEVALIDATE_API_KEY from the environment.
mv = MobileValidate(api_key="mv_test_publicSandboxn9ZgneuhR1B9CRfKG3fulym")
result = mv.lookup(numbers=["+447700900001"], checks=["telegram"])
print(result)

<?php
$ch = curl_init('https://api.mobilevalidate.com/v1/lookup');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer mv_test_publicSandboxn9ZgneuhR1B9CRfKG3fulym',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'numbers' => ['+447700900001'],
        'checks' => ['telegram'],
    ]),
]);
$response = curl_exec($ch);
echo curl_getinfo($ch, CURLINFO_RESPONSE_CODE), PHP_EOL, $response, PHP_EOL;

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{"numbers":["+447700900001"],"checks":["telegram"]}`)
	req, err := http.NewRequest("POST", "https://api.mobilevalidate.com/v1/lookup", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer mv_test_publicSandboxn9ZgneuhR1B9CRfKG3fulym")
	req.Header.Set("Content-Type", "application/json")
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

require "net/http"
require "json"

uri = URI("https://api.mobilevalidate.com/v1/lookup")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer mv_test_publicSandboxn9ZgneuhR1B9CRfKG3fulym"
req["Content-Type"] = "application/json"
req.body = JSON.generate({
  "numbers" => ["+447700900001"],
  "checks" => ["telegram"]
})

res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(req) }
puts res.code, res.body

Response (excerpt, test mode: the first item of results):

{
  "kind": "phone",
  "input": "+447700900001",
  "e164": "+447700900001",
  "country": "GB",
  "number_status": "valid",
  "checks": {
    "telegram.registered": {
      "service": "telegram.registered",
      "status": "completed",
      "registered": true,
      "attributes": null,
      "confidence": "high",
      "confidence_score": 0.99,
      "checked_at": "2026-09-25T14:25:29.556Z",
      "cached": false,
      "age_seconds": 0,
      "billed": false,
      "reason": null,
      "poll_after_ms": null
    }
  },
  "test": true
}