ForHosting KIT · Validation

Look up a phone carrier

A phone carrier lookup API answers the question a validated number alone cannot: who operates it, and what kind of line is it, mobile, landline or VoIP. That matters the moment you need to decide whether a number can even receive an SMS, or whether a call center should route it differently.

● BetaPer request + per item$0.002

Run — $0.002 How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Run it online

Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.

Validity is not the same as usability

A phone number can be perfectly valid, correctly formatted, structurally sound, and still be useless for your purpose. A landline cannot receive a text message. A VoIP number tied to a virtual office might be exactly what a signup flow wants to block, or exactly what a remote-friendly business wants to accept. Knowing the line type turns a pass or fail check into a number your systems can actually reason about.

What carrier lookup returns

Given a phone number, the endpoint returns the detected country, the current carrier or operator name where determinable, and the line type classification, mobile, landline, VoIP or unknown. Carrier detection reflects number portability and routing data rather than a fixed prefix table, since subscribers frequently move their number between operators while keeping the same digits, a reality that has made carrier lookups meaningfully harder than they were when area codes mapped cleanly to a single phone company.

How to read the result

Submit the request and you get a task_id right away; the actual detail, country, carrier, line type, arrives through your webhook or a signed link valid for 24 hours, consistent with how every task on this API resolves. When a number cannot be resolved to a specific carrier, perhaps because it belongs to a smaller regional operator or the portability data is incomplete, the response reflects that honestly as unknown rather than guessing.

A quick word on the mobile-landline-VoIP divide

Mobile numbers dominate global usage now, but landlines remain common for businesses and older demographics in many countries, and VoIP numbers, tied to services rather than physical lines, have grown fast because they are cheap to provision and easy to discard, which is exactly why fraud teams pay closer attention to them. Distinguishing the three is not cosmetic; it changes what a number can technically do and what risk profile it typically carries.

Putting it to work

Run carrier lookup right after phone validation in your signup flow to route mobile numbers into SMS verification and landlines into a voice call verification path instead. Fraud and risk teams use the VoIP flag as one signal among several when scoring new accounts, and call centers use carrier and line-type data to prioritize outbound campaigns toward numbers that can actually be reached. As with every task here, failed lookups are never charged and retry automatically up to three times.

What you can do with it

SMS-vs-voice routing

Route mobile numbers into SMS verification and landline numbers into a voice-call verification path automatically, instead of sending a text that a landline can never receive.

VoIP-based fraud scoring

Flag disposable VoIP numbers as one risk signal during account creation, since they are cheap to acquire and easy to abandon.

Outbound call center prioritization

Sort a call list so agents dial reachable mobile and landline numbers first and skip numbers that carrier data marks as unresolved or inactive-pattern.

International carrier reporting

Break down a customer contact database by country and carrier to understand where support or delivery partnerships might be worth strengthening.

FAQ

What does a phone carrier lookup API return?

It returns the detected country, the current carrier or operator name where it can be determined, and the line type, mobile, landline, VoIP or unknown.

Can it tell me if a number is mobile or landline?

Yes, line type classification, mobile, landline or VoIP, is a core part of the response from this phone carrier lookup API.

Is it free to use?

There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.

How much does each lookup cost?

Each request to /verify/phone-carrier costs 0.002 dollars, charged only for successfully completed tasks.

Why does carrier detection sometimes return unknown?

Number portability means a subscriber can switch operators while keeping their number, and smaller regional carriers or incomplete portability data can make the current operator unresolvable; the response reflects that honestly rather than guessing.

Do I need to validate the number first?

It is recommended to run phone validation first to confirm the number is structurally correct, then use carrier lookup for the operator and line-type detail; the two endpoints are designed to complement each other.

How do I receive the result?

You get a task_id immediately, and the country, carrier and line-type data arrive via your signed webhook or a signed link valid for 24 hours.

Does it work for numbers outside the United States?

Yes, carrier and line-type detection covers numbers worldwide, not a single country's numbering plan.

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/verify/phone-carrier

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/verify/phone-carrier \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"items":["valor-1","valor-2"]}'

const res = await fetch("https://api.kit.forhosting.com/verify/phone-carrier", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "items": [
      "valor-1",
      "valor-2"
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/verify/phone-carrier",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "items": [
        "valor-1",
        "valor-2"
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/verify/phone-carrier", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"items":["valor-1","valor-2"]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"items":["valor-1","valor-2"]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/verify/phone-carrier", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "items": [
    "valor-1",
    "valor-2"
  ]
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "verify.phone_carrier",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Read the full KIT documentation →