Contactability checks for collections and accounts receivable

Contactability checks help collections and accounts-receivable teams contact account holders on a channel that works, using only details the account holder gave them. A lookup reports whether the number is mobile or fixed, whether the mobile line is assigned and reachable, and whether the e-mail mailbox exists. It never locates people or reveals who holds a number.

#What problem does a contactability check solve?

Collections teams, lenders, utilities, telecoms and landlords all chase overdue payments, and they depend on contact details that were collected months or years earlier. By the time an account falls behind, those details have often decayed:

• Landlines on file. A text to a fixed line fails silently. The carrier lookup reports line_type, so you know which accounts can only be called or written to.
• Numbers no longer in service. Dialling unassigned numbers wastes agent time and dialler capacity. The HLR lookup asks the home network whether a mobile number is assigned (reachable or unreachable) or not (invalid).
• Mailboxes that bounce. An e-mail to an address that no longer exists isn't a notice anyone received. The e-mail mailbox check answers whether the mailbox exists at major webmail providers.
• Phones that are off. An unreachable answer suggests trying later, or another channel, rather than repeating the same attempt.

A check makes your existing contact attempts better aimed. It doesn't add new contact details, and it doesn't make any attempt lawful that wasn't already.

#What won't this service do?

Collections is an area where the line between contact quality and tracking people matters. So, explicitly:

• No skip tracing or locating. We don't find new numbers, addresses, employers, relatives or social profiles for anyone.
• No reverse lookups. We never return a name, photo or profile for a number or address.
• No location. The HLR lookup returns roaming as true or false only, never a place. We recommend collections teams don't store or act on the roaming flag at all.
• No proof of who holds a number. A reachable number may have been reassigned to someone else. See reassigned numbers.
• No decisions about people. Results must not be used for credit, employment, housing or insurance decisions.

Our acceptable use policy applies, and requests that look like number-range scans are refused.

#How does the workflow look?

1. Start from your records. Take the number and e-mail the account holder gave you, plus the channels they agreed to.
2. Run a bulk job before a campaign. Call POST /v1/jobs/estimate (free), then POST /v1/jobs with checks: ["carrier", "hlr", "email"] and the estimate as max_cost.
3. Classify each account. Mobile and reachable; mobile and unreachable; fixed line; not assigned; mailbox missing; unknown.
4. Send each class to compliance-approved treatment. For example: not-assigned numbers go to a records-review queue instead of the dialler; fixed lines go to call-only or letter strategies.
5. Check the US reassigned-numbers question separately. For US numbers you'll call or text under the TCPA, the FCC's Reassigned Numbers Database answers whether a number was permanently disconnected since a date you give.
6. Keep the evidence minimal. Store the class and checked_at with the account. Delete finished job data with DELETE /v1/jobs/{id} when you no longer need it; job data is kept for 30 days by default.

#Which checks answer which question?

#What should you do with each result?

#What does a request look like?

This test-mode lookup checks two numbers. +447700900001 is reachable and +447700900005 answers unsupported_country, which is free.

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

// 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", "+447700900005"],
  checks: ["hlr"],
});
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", "+447700900005"],
    checks: ["hlr"],
  }),
});
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", "+447700900005"], checks=["hlr"])
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', '+447700900005'],
        'checks' => ['hlr'],
    ]),
]);
$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","+447700900005"],"checks":["hlr"]}`)
	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", "+447700900005"],
  "checks" => ["hlr"]
})

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 checks of both items in results):

[
  {
    "number.hlr": {
      "service": "number.hlr", "status": "completed", "registered": true,
      "attributes": {"status": "reachable", "ported": false, "roaming": false, "network": "Test Mobile", "mcc_mnc": "23415", "country": "GB"},
      "confidence": "high", "confidence_score": 0.99, "checked_at": "2026-09-29T08:45:19.061Z",
      "cached": false, "age_seconds": 0, "billed": false, "reason": null, "poll_after_ms": null
    }
  },
  {
    "number.hlr": {
      "service": "number.hlr", "status": "unsupported_country", "registered": null, "attributes": null,
      "confidence": null, "confidence_score": null, "checked_at": null,
      "cached": false, "age_seconds": null, "billed": false, "reason": "UNSUPPORTED_COUNTRY", "poll_after_ms": null
    }
  }
]

For campaigns, send the same checks in a bulk job and download the results as CSV with one column per check.

#How much does it cost?

You pay only for conclusive answers. Unknown, unsupported-country, invalid and duplicate results are free. The HLR lookup costs $0.005 per number, in real time and in bulk; reachable, unreachable and invalid are conclusive and billed. The MNP lookup costs $0.001 per number. See pricing for the carrier and e-mail rates.

Compare that with the cost of an agent dialling a disconnected number, or a text sent to a landline. The free estimate shows the maximum cost of a job before anything runs, and repeat checks of the same number inside the freshness window come from your cache for free.

#What compliance points apply?

Debt collection is tightly regulated, and the rules differ by country, state and type of debt. In the United States:

• Regulation F implements the Fair Debt Collection Practices Act (12 CFR part 1006). Among other things it treats calls before 8 a.m. or after 9 p.m. at the consumer's location as inconvenient, presumes compliance with the call-frequency limits when a collector calls no more than seven times in seven days about a debt, and requires a way to opt out of electronic communications such as texts and e-mail.
• Third-party disclosure. Collectors generally may not discuss a debt with anyone other than the consumer. A reassigned number, a shared family phone or a lock-screen preview can all reach someone else, which is why message content and channel choice need review.
• The TCPA restricts autodialled and prerecorded calls and texts to mobile numbers without prior express consent (47 CFR 64.1200). The FCC offers a safe harbor for callers who check its Reassigned Numbers Database.

Other countries have their own rules. A contactability result is an input to that review, not a substitute for it. This page is not legal advice; your compliance team or counsel decides how these rules apply to you.

#What are the common mistakes?

• Using checks to hunt for people. They answer questions about details you already hold. They can't and mustn't be used to find anyone.
• Treating reachable as "right party". A number can be live and belong to someone else. Right-party verification happens in the conversation, under your scripts.
• Acting on the roaming flag. It adds nothing to a lawful contact strategy and invites misuse. Ignore it.
• Treating a registered app as consent. A messaging account only shows the channel exists.
• Re-dialling unreachable numbers in a loop. Space attempts out and count them against your frequency limits.
• Keeping job data forever. Store the class and date, delete the rest.