Phone Number to Letters Converter

A vanity phone number is a telephone number whose digits spell out a memorable word or phrase on the standard telephone keypad. The concept works because every digit from 2 to 9 maps to three or four letters, a convention dating back to the earliest days of telephone exchanges. If you enjoy converting between letters and numbers, you will find the same foundational concept at work on our letters to numbers converter — the mapping is just different (alphabetical positions vs. telephone keypad groupings).

Well-known examples include 1-800-FLOWERS (1-800-356-9377) and 1-800-CONTACTS (1-800-266-8228). They work because a word is easier to recall than an arbitrary digit string, and a caller who knows the word can dial it without looking anything up.

The standard telephone keypad assigns letters to number keys as follows:

2 = A B C | 3 = D E F | 4 = G H I | 5 = J K L | 6 = M N O | 7 = P Q R S | 8 = T U V | 9 = W X Y Z

This layout is the one set out in ITU-T Recommendation E.161. The digits 0 and 1 have no letter assignments. Keys 7 and 9 carry four letters each (PQRS and WXYZ) because 26 letters divided among 8 keys leaves two keys with an extra letter. For a visual reference, visit our T9 keypad chart.

The name "T9" stands for "Text on 9 keys" and originally referred to Tegic Communications' predictive text technology for feature phones. In common usage, "T9" now refers to any letter-digit mapping based on the telephone keypad, including the multi-tap input method used before predictive text existed.

Some of the most successful vanity numbers in business history include:

1-800-FLOWERS (356-9377): the seven letters of FLOWERS fill exactly the seven digits after the 1-800 prefix, so nothing is left over.

1-800-CONTACTS (266-8228):"CONTACTS" has 8 letters but only 7 digits follow the prefix, so the digits are 266-8228 and the final S (digit 7) falls beyond them. CONTACT is not in this tool's built-in word list, so it reports no word for 266-8228 (see the worked examples above).

1-800-GOT-JUNK (468-5865): the dash in GOT-JUNK marks the word boundary; the digits are 468-5865. Another example is 1-800-TAXICAB (829-4222).

For a deeper exploration of text-to-keypad conversion, try the T9 converter tool.

Selecting an effective vanity number involves several considerations. First, the word must be relevant to the business: a plumber wants a number containing PIPE or LEAK, not CAKE. Second, the word should be common enough that callers can spell it without hesitation. Third, the total digit count must match the required phone number length (7 digits for local, 10 for long-distance with area code).

Vanity numbers are most often built on a toll-free prefix such as 1-800, 1-888, 1-877 or 1-866 followed by a single, unmistakable word. Whether a given number is free to take depends on the carrier or toll-free provider, so check availability with them rather than assuming a word is open.

Our tool helps you explore what words any digit sequence can spell, making it useful for brainstorming vanity number options for your business or simply satisfying curiosity about what your existing phone number spells.

Each digit on the keypad maps to 3 or 4 letters, creating a combinatorial explosion. For a 7-digit number where each digit maps to 3 letters, there are 3^7 = 2,187 possible letter combinations. If some digits are 7 or 9 (with 4 letters each), the count increases — a number with all 7s and 9s would have 4^7 = 16,384 combinations.

Of course, the vast majority of these combinations are not real English words. The tool builds the letter combinations with recursive backtracking for the preview, and finds words the other way round: it checks each word in its built-in list against your digits. Here is the backtracking algorithm in JavaScript:

const KEYPAD = {
  '2': 'ABC', '3': 'DEF', '4': 'GHI',
  '5': 'JKL', '6': 'MNO', '7': 'PQRS',
  '8': 'TUV', '9': 'WXYZ'
};

function phoneToWords(digits) {
  const results = [];
  function backtrack(i, current) {
    if (i === digits.length) {
      results.push(current);
      return;
    }
    const letters = KEYPAD[digits[i]];
    if (!letters) return;
    for (const ch of letters) {
      backtrack(i + 1, current + ch);
    }
  }
  backtrack(0, '');
  return results;
}

// Example: what does 3569377 spell?
const combos = phoneToWords('3569377');
console.log(combos.length);  // 5,184 combinations (3·3·3·4·3·4·4)
// Filter for real words using a dictionary...

And the Python version:

KEYPAD = {
    '2': 'ABC', '3': 'DEF', '4': 'GHI',
    '5': 'JKL', '6': 'MNO', '7': 'PQRS',
    '8': 'TUV', '9': 'WXYZ'
}

def phone_to_words(digits):
    if not digits:
        return []
    results = []
    def backtrack(i, current):
        if i == len(digits):
            results.append(current)
            return
        for ch in KEYPAD.get(digits[i], ''):
            backtrack(i + 1, current + ch)
    backtrack(0, '')
    return results

combos = phone_to_words('3569377')
print(len(combos))  # 5184

This is a classic interview problem known as "Letter Combinations of a Phone Number" (LeetCode #17). It demonstrates the recursive backtracking pattern and has O(4^n) time complexity where n is the number of digits.