Every central office code in the North American Numbering Plan,
matched to the ZIP Codes it serves and the carrier that holds it. Last updated
June23, 2026
(2 months ago).
Both editions carry the same 562,060 rows and the same coverage.
Standard tells you a number exists and roughly where it is. Deluxe tells you who runs it,
what kind of line it is, and where the people it serves actually live.
What you can do with it
Deluxe$449.95/yr
Standard$249.95/yr
Validating a phone number
Confirm an NPA-NXX exists at allNPA · NXX · NPANXX — every assigned central office code in the plan
✓
✓
Place the number in a state or provinceState — two-letter code, U.S. states, Canadian provinces and NANP territories
✓
✓
Match a number to a ZIP CodeZipCode · ZipCodeCount · ZipCodeFreq — an exchange usually reaches several ZIPs, so ZipCodeFreq tells you the main one
✓
✓
Know the regulatory calling regionLATA — Local Access and Transport Area
✓
✓
Reject numbers in retired exchangesStatus — 96,650 of the 562,060 rows are Inactive and ship on purpose, because rejecting a number needs them
✓
Standard ends here
Knowing who runs the number
Identify the carrier holding the codeCompany · OCN — the Operating Company Number and its name
79%of records
Tell a landline from a wireless numberNXXUseType — L or W. The single most-asked-for field on this product, and what TCPA screening runs on.
83%of records
Route by rate centerRateCenter · CoverageAreaName
✓
Spot a newly opened exchangeNXXIntroVersion — the release in which the NXX first appeared
✓
Know an area code is an overlayOverlay — L marks a recent overlay on an existing geographic area
✓
Putting it on a map
Place the central officeLatitude · Longitude — where the switch is
83%resolved
Place the people the exchange servesWeightedLat · WeightedLon — the centroid of the ZIP Code the exchange most often reaches. For territories, lead routing and customer mapping this is the pair you want, not the switch.
78%resolved
Name the city and countyCity · County · CoverageAreaName
✓
Join to federal geographyFIPS · MSA_CBSA · MSA_CBSA_CODE — county FIPS and the Census statistical area
✓
Calling at the right time
Know the time zoneTimeZone — hours behind GMT, 4 Atlantic through 11 and beyond for the Pacific territories
✓
Know whether it observes DSTObservesDST — Y or N. Arizona outside the Navajo Nation, Hawaii, Puerto Rico and parts of Indiana do not.
Why the percentages, and why they are not higher. The numbering plan includes codes
that are reserved, unassigned to a carrier, or held by an administrator rather than an
operator, and Canadian and territory records are carried for reference rather than
maintained to the same standard. Those rows are still in the file — you need them to
recognize a code — but they have no carrier to name and no serving office to place.
Roughly four rows in five carry the full picture. We would rather show you the figure than
a tick that implies five in five.
Two coordinates, two different questions.Latitude / Longitude
place the central office — the switch. WeightedLat /
WeightedLon place the centroid of the ZIP Code the exchange most often serves
— the people. If you are drawing sales territories, routing leads or mapping
customers, the weighted pair is almost always the one you want; the switch can sit in an
industrial park miles from anyone it serves.
Reading the colors: populated, with the real coverage figure✓ present on every rowHatched = not in that edition.
Both editions cover the whole North American Numbering Plan — all 50 states, DC,
Puerto Rico, Guam, the U.S. Virgin Islands, the Northern Mariana Islands, American Samoa
and the Canadian provinces and territories — delivered as a single file in CSV,
tab-delimited and Microsoft Access formats. Field counts and coverage percentages measured
from the June2026 build.
See every column on the
technical specifications page.
Sample downloads
Real records from the production file, not mock data, so you can
test your importer against the actual layout before you buy. Each sample carries the data in
all three formats and that edition’s specification sheet. No email required.
Deluxe
31 columns
The full layout — carrier, OCN, rate center, landline/wireless,
both coordinate pairs, time zone, county, FIPS and CBSA.
The first six digits of a North American phone number, and the
level at which telecom geography is actually assigned. There are only
431 area codes — but
562,060 rows in this file, and the difference is the whole
product.
Reading the number
NPA is the area code — the Numbering Plan Area. The
212 in (212) 555-1234.
NXX is the central office prefix, the next three digits. The
555.
NPANXX is the two joined: 212555. This is the key almost
every system indexes on.
The last four digits identify the individual line, and are not in any
database — nor should they be.
Why there are half a million rows
An area code covers a region; an exchange covers a neighborhood.
One exchange usually reaches several ZIP Codes, so it appears once per
ZIP Code it serves.
ZipCodeFreq ranks those: which ZIP the exchange mostly serves,
which is second, and by how much.
So NPANXX is not unique in this file. Filter on frequency
if you want one row per exchange.
What it is good for
Validation — does this six-digit prefix exist, and is it live?
Classification — landline or wireless, which is what TCPA
screening runs on.
Location — state, city, county, ZIP, coordinates, time zone.
Attribution — which carrier holds the code, and in which rate
center.
What it is not
It is not a phone directory. There are no subscriber names or numbers
here, and there never will be.
It does not follow ported numbers. A number that moved carrier still
reads as its original code holder — that needs a live LNP dip, not a
database.
It does not know where a mobile is. A wireless number reports where it
was issued, not where the handset is now.
It is a quarterly snapshot, not a real-time feed.
That last box is the honest one. If you need portability or live status, no
downloadable file can give it to you — ours included.
Nine things customers actually do with this file. Each one
names the columns it runs on and the edition that carries them — which is worth
reading before you choose, because carrier, line type, coordinates and time zone all
live in Deluxe.
Number Validation
Validate phone numbers in web forms, CRM imports or batch pipelines. Confirm an area code and exchange combination exists before you attempt delivery, cutting bounce rates and cleaning up customer records. Deluxe adds Status, so you can also reject numbers in retired exchanges rather than only unknown ones.
Key fields: NPANXX, NPA, NXX, State
Works on Standard
Call Routing Systems
Route inbound calls based on area code, time zone, or rate center. Implement least-cost routing using carrier and LATA data. Perfect for contact centers, VoIP platforms, and toll-free number management.
Key fields: NPA, NXX, RateCenter, TimeZone, LATA, Carrier, State
Needs Deluxe
Fraud Detection & Security
Flag suspicious numbers from inactive NPA-NXX blocks or newly assigned exchanges. Cross-reference carrier data to detect caller ID spoofing. Identify high-risk area codes and verify caller authenticity in real-time authentication systems.
Key fields: Status, NXXIntroVersion, Company, OCN, State
Needs Deluxe
CRM Data Enrichment
Append geographic location, carrier information, and service type to existing customer phone numbers. Enhance marketing segmentation with wireless/landline classification. Fill gaps in incomplete customer records with ZIP code correlations.
Key fields: City, County, State, ZipCode, NXXUseType, Company
Needs Deluxe
Time Zone & Scheduling
Schedule outbound calls during appropriate business hours based on phone number time zones. Respect DST observance for Arizona and Hawaii. Optimize contact center staffing by predicting call volume across time zones.
Analyze call patterns by region, carrier type, or service area. Track number pool assignments over time using historical status data. Generate market intelligence reports on telecom infrastructure and carrier distribution.
Key fields: OCN, Company, MSA_CBSA, County, NXXUseType, Status
Needs Deluxe
E911 Emergency Services
Route emergency calls to appropriate dispatch centers using rate center and county data. Determine jurisdiction boundaries for 911 call handling. Support VoIP E911 compliance requirements with accurate geographic attribution.
Key fields: RateCenter, County, State, FIPS, Latitude, Longitude
Needs Deluxe
Marketing Compliance (TCPA)
Identify wireless numbers before calling to comply with TCPA regulations. Maintain proper consent records for mobile marketing campaigns. Reduce legal risk by classifying phone types before outbound marketing activities.
Key fields: NXXUseType, State, Status
Needs Deluxe
Geographic Targeting
Target marketing campaigns by geographic region using area code intelligence. Display local phone numbers to visitors based on their location. Optimize service coverage by mapping customer density to rate centers and MSAs.
Key fields: State, City, County, MSA_CBSA, ZipCode, Latitude, Longitude
Needs Deluxe
Seven of these nine need Deluxe. Carrier, line type, coordinates and time
zone are the columns doing the work.
The same lookup in six languages: read the file, index it
correctly, and resolve a phone number to a location, a carrier and a line type. Written
against the real column names and the real quirks — not pseudocode.
Three things that catch people out
The file has a UTF-8 byte-order mark. Read it as utf-8-sig,
or strip EF BB BF yourself — otherwise your first column is
named \uFEFFState and every lookup on State misses.
NPANXX is not unique. An exchange appears once per ZIP Code
it serves, so keying a map on it keeps only the last one. Rank on
ZipCodeFreq and keep the primary, or use a composite key.
ZipCodeFreq has sentinel values. It is a percentage, except
that -1 means “most frequent, share unknown”,
-2 means “second most frequent” and 0
means unknown. Sorting on the raw number puts the best row last.
Python — resolve a number to location, carrier and line type
import csv
# encoding="utf-8-sig" strips the BOM. With plain "utf-8" the first
# column is named "\uFEFFNPA" and every lookup on it silently fails.
PATH = "DeluxeAreaCodeDatabase.csv"
def rank(freq):
"""ZipCodeFreq is a percentage EXCEPT for three sentinels:
-1 = most frequent (share unknown), -2 = second, 0 = unknown.
Map them onto one scale so a plain max() picks the right row."""
f = int(freq or 0)
if f == -1:
return 101.0
if f == -2:
return 100.0
if f == 0:
return -1.0
return float(f)
# NPANXX is NOT unique - an exchange appears once per ZIP Code it
# serves. Keep the PRIMARY ZIP for each exchange rather than whichever
# row happened to come last.
exchanges = {}
with open(PATH, encoding="utf-8-sig", newline="") as fh:
for row in csv.DictReader(fh):
key = row["NPANXX"]
best = exchanges.get(key)
if best is None or rank(row["ZipCodeFreq"]) > rank(best["ZipCodeFreq"]):
exchanges[key] = row
def lookup(phone):
digits = "".join(c for c in phone if c.isdigit())
if len(digits) == 11 and digits[0] == "1": # leading country code
digits = digits[1:]
if len(digits) < 6:
return {"valid": False, "reason": "too short"}
row = exchanges.get(digits[:6])
if row is None:
return {"valid": False, "npanxx": digits[:6],
"reason": "no such exchange"}
# A coordinate of 0,0 is a null wearing a number's clothes.
lat, lon = float(row["WeightedLat"]), float(row["WeightedLon"])
return {
"valid": True,
"npanxx": row["NPANXX"],
"active": row["Status"] == "Active",
"state": row["State"],
"city": row["City"] or None,
"zip": row["ZipCode"] or None,
"carrier": row["Company"] or None,
"line": {"L": "landline", "W": "wireless"}.get(row["NXXUseType"]),
"tz": row["TimeZone"] or None,
"dst": row["ObservesDST"] == "Y",
"point": (lat, lon) if (lat or lon) else None,
}
r = lookup("(212) 555-1234")
print(r["state"], r["city"], r["carrier"], r["line"], r["active"])
Memory: the full Deluxe file is 562,060 rows; indexed
this way you keep one row per exchange, which is roughly 200,000 entries and about
300–400 MB as Python dicts. If that is too much, keep only the seven fields you
need per row, or load it into SQLite and query it.
PHP — same lookup, BOM stripped explicitly
<?php
$path = 'DeluxeAreaCodeDatabase.csv';
// ZipCodeFreq sentinels: -1 most frequent, -2 second, 0 unknown.
function zipRank($freq) {
$f = (int)$freq;
if ($f === -1) return 101.0;
if ($f === -2) return 100.0;
if ($f === 0) return -1.0;
return (float)$f;
}
$exchanges = [];
$fh = fopen($path, 'r');
// fgetcsv does not strip the BOM, so the first header would come back
// as "\xEF\xBB\xBFNPA". Remove it from the header row by hand.
$headers = fgetcsv($fh);
$headers[0] = preg_replace('/^\xEF\xBB\xBF/', '', $headers[0]);
while (($cols = fgetcsv($fh)) !== false) {
if (count($cols) !== count($headers)) continue;
$row = array_combine($headers, $cols);
$key = $row['NPANXX'];
// keep the PRIMARY ZIP - NPANXX repeats once per ZIP Code served
if (!isset($exchanges[$key])
|| zipRank($row['ZipCodeFreq']) > zipRank($exchanges[$key]['ZipCodeFreq'])) {
$exchanges[$key] = $row;
}
}
fclose($fh);
function lookupPhone($phone, $exchanges) {
$digits = preg_replace('/\D/', '', $phone);
if (strlen($digits) === 11 && $digits[0] === '1') {
$digits = substr($digits, 1);
}
if (strlen($digits) < 6) {
return ['valid' => false, 'reason' => 'too short'];
}
$npanxx = substr($digits, 0, 6);
if (!isset($exchanges[$npanxx])) {
return ['valid' => false, 'npanxx' => $npanxx,
'reason' => 'no such exchange'];
}
$r = $exchanges[$npanxx];
$lat = (float)$r['WeightedLat'];
$lon = (float)$r['WeightedLon'];
return [
'valid' => true,
'npanxx' => $r['NPANXX'],
'active' => $r['Status'] === 'Active',
'state' => $r['State'],
'city' => $r['City'] ?: null,
'zip' => $r['ZipCode'] ?: null,
'carrier' => $r['Company'] ?: null,
'line' => ['L' => 'landline', 'W' => 'wireless'][$r['NXXUseType']] ?? null,
'point' => ($lat || $lon) ? [$lat, $lon] : null,
];
}
$r = lookupPhone('(212) 555-1234', $exchanges);
echo $r['state'], ' ', $r['city'], ' ', $r['carrier'], PHP_EOL;
Do not do this per request. Parsing the CSV on every
page load will dominate your response time. Build the index once into APCu, Redis or
a real table, and read from that.
Node.js — streamed, so the 110 MB file never lands in memory whole
const fs = require('fs');
const readline = require('readline');
const PATH = 'DeluxeAreaCodeDatabase.csv';
// ZipCodeFreq sentinels: -1 most frequent, -2 second, 0 unknown.
const rank = (f) => {
const v = parseInt(f, 10) || 0;
return v === -1 ? 101 : v === -2 ? 100 : v === 0 ? -1 : v;
};
// Minimal CSV split. The Company and MSA_CBSA columns contain commas
// inside quotes, so a plain .split(',') is not enough.
function parseLine(line) {
const out = [];
let cur = '', quoted = false;
for (let i = 0; i < line.length; i++) {
const c = line[i];
if (quoted) {
if (c === '"' && line[i + 1] === '"') { cur += '"'; i++; }
else if (c === '"') quoted = false;
else cur += c;
} else if (c === '"') quoted = true;
else if (c === ',') { out.push(cur); cur = ''; }
else cur += c;
}
out.push(cur);
return out;
}
async function loadExchanges() {
const exchanges = new Map();
let headers = null;
const rl = readline.createInterface({
input: fs.createReadStream(PATH, 'utf8'),
crlfDelay: Infinity,
});
for await (let line of rl) {
if (!line) continue;
if (!headers) {
// strip the UTF-8 BOM from the very first character
if (line.charCodeAt(0) === 0xFEFF) line = line.slice(1);
headers = parseLine(line);
continue;
}
const cols = parseLine(line);
if (cols.length !== headers.length) continue;
const row = {};
headers.forEach((h, i) => { row[h] = cols[i]; });
// NPANXX repeats once per ZIP Code served - keep the primary
const prev = exchanges.get(row.NPANXX);
if (!prev || rank(row.ZipCodeFreq) > rank(prev.ZipCodeFreq)) {
exchanges.set(row.NPANXX, row);
}
}
return exchanges;
}
function lookup(phone, exchanges) {
let d = String(phone).replace(/\D/g, '');
if (d.length === 11 && d[0] === '1') d = d.slice(1);
if (d.length < 6) return { valid: false, reason: 'too short' };
const r = exchanges.get(d.slice(0, 6));
if (!r) return { valid: false, npanxx: d.slice(0, 6), reason: 'no such exchange' };
const lat = parseFloat(r.WeightedLat), lon = parseFloat(r.WeightedLon);
return {
valid: true,
npanxx: r.NPANXX,
active: r.Status === 'Active',
state: r.State,
city: r.City || null,
carrier: r.Company || null,
line: r.NXXUseType === 'W' ? 'wireless' : r.NXXUseType === 'L' ? 'landline' : null,
point: (lat || lon) ? [lat, lon] : null,
};
}
(async () => {
const exchanges = await loadExchanges();
console.log(lookup('(212) 555-1234', exchanges));
})();
Why stream it:fs.readFileSync on the
Deluxe CSV allocates a single ~110 MB string, which on the default heap is enough to
matter. Reading line by line keeps the peak to the index you are building.
SQL — import, index and query
-- ---------------------------------------------------------------
-- NPANXX is NOT unique. One exchange appears once per ZIP Code it
-- serves, so NPANXX cannot be the primary key - the import fails on
-- the second row. The natural key is (NPANXX, ZipCode).
-- ---------------------------------------------------------------
CREATE TABLE npanxx (
NPANXX CHAR(6) NOT NULL,
NPA CHAR(3) NOT NULL,
NXX CHAR(3) NOT NULL,
ZipCode CHAR(5) NULL, -- CHAR, not INT: leading zeros
ZipCodeCount INT NULL,
ZipCodeFreq SMALLINT NULL, -- -1 / -2 / 0 are sentinels
State CHAR(2) NULL,
City VARCHAR(64) NULL,
County VARCHAR(64) NULL,
FIPS CHAR(5) NULL, -- CHAR: leading zeros
LATA VARCHAR(8) NULL,
TimeZone TINYINT NULL,
ObservesDST CHAR(1) NULL, -- 'Y' / 'N', NOT 1/0
NXXUseType CHAR(1) NULL, -- 'L' landline, 'W' wireless
RateCenter VARCHAR(16) NULL,
OCN CHAR(4) NULL, -- CHAR: alphanumeric, can lead 0
Company VARCHAR(96) NULL,
Status VARCHAR(8) NULL,
Latitude DECIMAL(12,8) NULL, -- the switch
Longitude DECIMAL(12,8) NULL,
WeightedLat DECIMAL(12,8) NULL, -- the people
WeightedLon DECIMAL(12,8) NULL,
PRIMARY KEY (NPANXX, ZipCode)
);
CREATE INDEX idx_npanxx ON npanxx (NPANXX);
CREATE INDEX idx_state ON npanxx (State);
CREATE INDEX idx_ocn ON npanxx (OCN);
-- MySQL import. CHARACTER SET utf8mb4 handles the BOM as part of the
-- first field of the header row, which IGNORE 1 ROWS then discards.
LOAD DATA INFILE 'DeluxeAreaCodeDatabase.csv'
INTO TABLE npanxx
CHARACTER SET utf8mb4
FIELDS TERMINATED BY ',' ENCLOSED BY '"'
LINES TERMINATED BY '\r\n'
IGNORE 1 ROWS (NPA, NXX, @CountyPop, ZipCodeCount, ZipCodeFreq,
Latitude, Longitude, State, City, County, TimeZone,
ObservesDST, NXXUseType, @NXXIntroVersion, ZipCode,
@NPANew, FIPS, LATA, @Overlay, RateCenter, @SwitchCLLI,
@MSA, @MSACode, OCN, Company, @CoverageAreaName,
NPANXX, @Flags, Status, WeightedLat, WeightedLon);
-- ---------------------------------------------------------------
-- One row per exchange: the PRIMARY ZIP Code, ranked past the
-- sentinel values. This is the view most applications should query.
-- ---------------------------------------------------------------
CREATE VIEW npanxx_primary AS
SELECT n.*
FROM npanxx n
JOIN (
SELECT NPANXX,
MAX(CASE ZipCodeFreq WHEN -1 THEN 101
WHEN -2 THEN 100
WHEN 0 THEN -1
ELSE ZipCodeFreq END) AS best
FROM npanxx GROUP BY NPANXX
) b ON b.NPANXX = n.NPANXX
AND b.best = CASE n.ZipCodeFreq WHEN -1 THEN 101
WHEN -2 THEN 100
WHEN 0 THEN -1
ELSE n.ZipCodeFreq END;
-- Validate one number
SELECT NPANXX, State, City, Company AS Carrier,
CASE NXXUseType WHEN 'W' THEN 'Wireless'
WHEN 'L' THEN 'Landline' END AS LineType,
Status, TimeZone, WeightedLat, WeightedLon
FROM npanxx_primary
WHERE NPANXX = LEFT(REGEXP_REPLACE('(212) 555-1234', '[^0-9]', ''), 6);
-- Enrich a customer table. Join the VIEW, not the table, or every
-- customer multiplies by the number of ZIP Codes their exchange serves.
UPDATE customers c
JOIN npanxx_primary n ON n.NPANXX = LEFT(c.phone_digits, 6)
SET c.phone_state = n.State,
c.phone_city = n.City,
c.phone_carrier = n.Company,
c.phone_type = CASE n.NXXUseType WHEN 'W' THEN 'Wireless'
WHEN 'L' THEN 'Landline' END
WHERE c.phone_digits IS NOT NULL;
The join above is the one that goes wrong. Joining
npanxx directly instead of npanxx_primary multiplies every
customer row by the number of ZIP Codes their exchange reaches — often three or
four, sometimes twenty. It is a silent bug: the update succeeds and the row counts
look plausible.
C# / .NET — streamed load into a lookup dictionary
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
public sealed record Exchange(
string Npanxx, string State, string City, string Zip,
string Carrier, string LineType, bool Active,
double? Lat, double? Lon);
public static class NpaNxxIndex
{
// ZipCodeFreq sentinels: -1 most frequent, -2 second, 0 unknown.
static double Rank(string freq) =>
int.TryParse(freq, out var f)
? f switch { -1 => 101, -2 => 100, 0 => -1, _ => f }
: -1;
public static Dictionary<string, Exchange> Load(string path)
{
// new UTF8Encoding(true) plus detectEncodingFromByteOrderMarks
// consumes the BOM; without it the first header is "\uFEFFNPA".
using var rdr = new StreamReader(path, Encoding.UTF8, true);
var header = SplitCsv(rdr.ReadLine()!);
var idx = header
.Select((h, i) => (h, i))
.ToDictionary(t => t.h, t => t.i);
var best = new Dictionary<string, (double rank, Exchange ex)>();
string? line;
while ((line = rdr.ReadLine()) != null)
{
if (line.Length == 0) continue;
var c = SplitCsv(line);
if (c.Length != header.Length) continue;
string Get(string col) => c[idx[col]];
var key = Get("NPANXX");
var rank = Rank(Get("ZipCodeFreq"));
if (best.TryGetValue(key, out var prev) && prev.rank >= rank)
continue;
double.TryParse(Get("WeightedLat"), NumberStyles.Float,
CultureInfo.InvariantCulture, out var lat);
double.TryParse(Get("WeightedLon"), NumberStyles.Float,
CultureInfo.InvariantCulture, out var lon);
best[key] = (rank, new Exchange(
key, Get("State"),
Get("City") is { Length: > 0 } ci ? ci : null!,
Get("ZipCode") is { Length: > 0 } z ? z : null!,
Get("Company") is { Length: > 0 } co ? co : null!,
Get("NXXUseType") switch { "L" => "landline",
"W" => "wireless", _ => null! },
Get("Status") == "Active",
(lat == 0 && lon == 0) ? null : lat,
(lat == 0 && lon == 0) ? null : lon));
}
return best.ToDictionary(kv => kv.Key, kv => kv.Value.ex);
}
public static Exchange? Lookup(
IReadOnlyDictionary<string, Exchange> index, string phone)
{
var d = new string(phone.Where(char.IsDigit).ToArray());
if (d.Length == 11 && d[0] == '1') d = d[1..];
if (d.Length < 6) return null;
return index.TryGetValue(d[..6], out var ex) ? ex : null;
}
static string[] SplitCsv(string line)
{
var outp = new List<string>();
var sb = new StringBuilder();
bool q = false;
for (int i = 0; i < line.Length; i++)
{
var ch = line[i];
if (q)
{
if (ch == '"' && i + 1 < line.Length && line[i + 1] == '"')
{ sb.Append('"'); i++; }
else if (ch == '"') q = false;
else sb.Append(ch);
}
else if (ch == '"') q = true;
else if (ch == ',') { outp.Add(sb.ToString()); sb.Clear(); }
else sb.Append(ch);
}
outp.Add(sb.ToString());
return outp.ToArray();
}
}
Culture matters here. Parse the coordinates with
CultureInfo.InvariantCulture. On a machine with a comma decimal
separator, double.Parse("40.7175") returns 407175.
Java — streamed load, primary ZIP kept per exchange
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
public final class NpaNxxIndex {
public record Exchange(String npanxx, String state, String city,
String zip, String carrier, String lineType,
boolean active, Double lat, Double lon) {}
// ZipCodeFreq sentinels: -1 most frequent, -2 second, 0 unknown.
private static double rank(String freq) {
try {
int f = Integer.parseInt(freq.trim());
return switch (f) { case -1 -> 101; case -2 -> 100;
case 0 -> -1; default -> f; };
} catch (Exception e) { return -1; }
}
public static Map<String, Exchange> load(Path path) throws IOException {
Map<String, Exchange> out = new HashMap<>(220_000);
Map<String, Double> bestRank = new HashMap<>(220_000);
try (BufferedReader r = Files.newBufferedReader(
path, StandardCharsets.UTF_8)) {
String head = r.readLine();
// Files.newBufferedReader does NOT strip the BOM
if (head != null && !head.isEmpty() && head.charAt(0) == '\uFEFF') {
head = head.substring(1);
}
String[] header = split(head);
Map<String, Integer> idx = new HashMap<>();
for (int i = 0; i < header.length; i++) idx.put(header[i], i);
String line;
while ((line = r.readLine()) != null) {
if (line.isEmpty()) continue;
String[] c = split(line);
if (c.length != header.length) continue;
String key = c[idx.get("NPANXX")];
double rk = rank(c[idx.get("ZipCodeFreq")]);
Double prev = bestRank.get(key);
if (prev != null && prev >= rk) continue;
double lat = parse(c[idx.get("WeightedLat")]);
double lon = parse(c[idx.get("WeightedLon")]);
boolean placed = !(lat == 0 && lon == 0);
bestRank.put(key, rk);
out.put(key, new Exchange(
key,
c[idx.get("State")],
blank(c[idx.get("City")]),
blank(c[idx.get("ZipCode")]),
blank(c[idx.get("Company")]),
switch (c[idx.get("NXXUseType")]) {
case "L" -> "landline"; case "W" -> "wireless";
default -> null; },
"Active".equals(c[idx.get("Status")]),
placed ? lat : null,
placed ? lon : null));
}
}
return out;
}
public static Optional<Exchange> lookup(
Map<String, Exchange> index, String phone) {
String d = phone.replaceAll("\\D", "");
if (d.length() == 11 && d.charAt(0) == '1') d = d.substring(1);
if (d.length() < 6) return Optional.empty();
return Optional.ofNullable(index.get(d.substring(0, 6)));
}
private static String blank(String v) {
return (v == null || v.isEmpty()) ? null : v;
}
private static double parse(String v) {
try { return Double.parseDouble(v); } catch (Exception e) { return 0; }
}
private static String[] split(String line) {
List<String> out = new ArrayList<>(32);
StringBuilder sb = new StringBuilder();
boolean q = false;
for (int i = 0; i < line.length(); i++) {
char ch = line.charAt(i);
if (q) {
if (ch == '"' && i + 1 < line.length()
&& line.charAt(i + 1) == '"') { sb.append('"'); i++; }
else if (ch == '"') q = false;
else sb.append(ch);
} else if (ch == '"') q = true;
else if (ch == ',') { out.add(sb.toString()); sb.setLength(0); }
else sb.append(ch);
}
out.add(sb.toString());
return out.toArray(new String[0]);
}
}
Spring Boot: load this once as a
@Bean singleton at startup, not per request. For anything larger than a
single service, import into your database and query it there instead.
These are deliberately dependency-free. Use a real CSV library in production
— the hand-rolled splitters above are here so the parsing quirks are visible,
not because they are the best tool.
Everything worth knowing before you buy. Deeper implementation
questions — import quirks, field semantics, format differences — live on the
technical FAQ.
Each edition offers different levels of data depth:
Standard ($249.95/yr):9 fields — NPA, NXX, NPANXX, State, LATA, the ZIP Code correlation with its count and frequency ranking, and the record flag. Enough to confirm a number exists and place it in a state and a ZIP Code.
Deluxe ($449.95/yr):31 fields — everything in Standard plus 22 more: two coordinate pairs (the central office and the population-weighted centroid), city, county, county population, FIPS, MSA/CBSA name and code, time zone and DST flag, carrier name and OCN, rate center, coverage area, landline/wireless classification, overlay marker, first-appearance version and active/inactive status.
NPA-NXX (also called NPANXX or Area Code Database) represents North American telephone numbering assignments. NPA is the 3-digit area code (like 212), and NXX is the 3-digit exchange prefix (like 555). Together they identify the first 6 digits of a 10-digit phone number and determine its geographic location, carrier, and routing information.
This data is essential for:
Call routing systems: Route calls based on geographic location, time zone, or carrier
Number validation: Verify phone numbers belong to valid area code/exchange combinations
Fraud detection: Flag suspicious or newly assigned NPA-NXX blocks
Time zone determination: Schedule calls during appropriate business hours
Geographic attribution: Map phone numbers to cities, counties, and states
CRM enrichment: Append carrier and location data to customer records
Telecom analytics: Analyze call patterns by region, carrier type, or service area
Unlike individual phone number lookups, NPA-NXX data gives you the infrastructure intelligence behind the North American telephone network-no per-query fees, no rate limits, just complete control over your routing and validation logic.
Every purchase includes 12 months of quarterly updates at no additional cost. Four times per year, we synchronize with NANPA updates and release a fresh version of the complete database. Each update is a full file refresh-not incremental deltas-ensuring data consistency.
Access your updates two ways:
Manual Download: Log into your account and download the latest version anytime
Automated FTP/SFTP/FTPS: We'll set up free secure FTP access so you can automate quarterly imports
After 12 months, you keep all the data you've downloaded. Renewal is only needed if you want to continue receiving quarterly updates.
Timing: Updates are typically released mid-quarter (January, April, July, October). We send email notifications to all active subscribers when new releases are available.
Yes! You can upgrade at any time by simply paying the price difference. Your subscription end date remains the same, and you'll immediately get access to the additional 19 data fields in the Deluxe edition.
For example, if you purchased Standard ($249.95) and want to upgrade to Deluxe ($449.95), you'd pay $200 (the difference), and your 12-month update period stays unchanged. This is accessible directly from your Account Homepage. It will list all of your subscriptions and offer an immediate upgrade option. No waiting, the upgrade is instantaneous. Contact us if you have any further questions.
Every subscription includes:
12 months of updates: Four quarterly full-file refreshes synchronized with NANPA
All file formats: CSV, Tab-Delimited (TAB), and Microsoft Access (MDB)
Immediate download: Access your data within minutes of purchase
Free FTP/SFTP/FTPS access: Automate your quarterly updates (setup on request)
Unlimited internal use: No per-user fees, no query limits, no throttling
Email & phone support: Real people ready to help with implementation questions
30-day money-back guarantee: Full refund if you're not satisfied, no questions asked
You keep the data forever: After your subscription ends, you retain all downloaded files. Renewal is only required if you want continued quarterly updates.
ZIP code boundaries and telephone exchange boundaries don't align perfectly-they were designed for different purposes (postal delivery vs. telecom infrastructure). Our database includes ZipCodeFreq rankings to show which ZIP codes are most commonly associated with each NPA-NXX:
ZipCodeFreq = -1: Most frequent (primary service area)
ZipCodeFreq = -2: Second most frequent
ZipCodeFreq = 0: Frequency data unavailable
We also include ZipCodeCount (population estimate) to help you assess reliability. ZIP codes with less than 2% frequency are excluded as statistically insignificant.
Best practices: For precise applications, use the -1 ranked ZIP codes, which represent the primary service area. For comprehensive coverage, include -2 ranked codes as well. The combination provides excellent geographic attribution for most business applications.
Our database is derived directly from NANPA (North American Numbering Plan Administration)-the official authority for area code and exchange assignments. This is the same authoritative source used by all telecom carriers in North America.
Our quality process:
Quarterly NANPA synchronization: We process official assignment files every quarter
Cross-reference validation: ZIP code correlations verified against USPS and Census data
Internal enrichment: Coordinates, time zones, and carrier data undergo additional QA
Format normalization: All fields cleaned, standardized, and validated before release
Accuracy considerations: While NANPA assignment data is definitive, some fields reflect point-in-time snapshots. Carrier assignments can change (especially with number portability), and new NPA-NXX blocks are issued monthly. Our quarterly updates keep you current within a 3-month window, which is sufficient for most business applications.
Bottom line: For NPA-NXX assignments, geographic locations, and rate center data, this is the most authoritative source available outside of direct carrier records.
The NXXUseType field (L=Landline, W=Wireless) is derived from NANPA's official assignments and reflects the original carrier type when the NPA-NXX block was assigned. This data is accurate at the block level.
Important caveats:
Number portability: Individual phone numbers may have moved between carriers/types since the original assignment. A "wireless" block may contain ported landline numbers and vice versa.
VoIP complexity: Modern VoIP services blur the line between traditional categories
Statistical reliability: While not 100% accurate at the individual number level, the classification is highly reliable for aggregate analysis
For critical applications requiring definitive real-time wireless/landline identification (like TCPA compliance), consider supplementing with a real-time lookup service that checks current line type and portability status.
Rate centers are geographic boundaries originally created to determine local calling areas and billing zones. Each NPA-NXX is assigned to a specific rate center, which defines its "home" location within the telephone network.
Why rate centers still matter:
E911 emergency routing: Rate centers help determine which emergency dispatch center receives calls
Network infrastructure: Telecom equipment and switches are organized by rate center
Regulatory compliance: Many telecom regulations reference rate center boundaries
Least-cost routing: Call routing systems use rate centers to optimize routing paths
Geographic precision: Rate centers provide finer geographic granularity than area codes alone
Common applications:
Toll-free routing (route 1-800 calls to nearest rate center)
Service area mapping (define coverage by rate center)
Historical analysis (rate centers are stable over time)
Available in: Deluxe edition only. Standard edition does not include rate center assignments.
The Status field indicates whether an NPA-NXX combination is currently in service:
"Active": The code is currently assigned and in use for telephone services
"Inactive": The code is reserved for future use or returned to the available pool
Why we include inactive records:
Historical analysis: Track how number assignments change over time
Data continuity: Maintain consistent record counts across updates
Fraud detection: Old/inactive codes being used can signal spoofing
Migration planning: Understand what codes are being phased out
Best practices:
For production routing/validation: Filter to Status='Active' only
For analytics: Include both active and inactive for complete historical view
For fraud detection: Flag calls from inactive NPA-NXX as suspicious
Available in: Deluxe edition only. Standard edition does not include status tracking.
OCN (Operating Company Number) is a unique 4-character identifier assigned by NECA (National Exchange Carrier Association) to each telecommunications carrier. The Company field shows the human-readable carrier name.
Key differences:
Attribute
OCN
Company Name
Format
4 characters (e.g., "9206")
Variable text (e.g., "Verizon New Jersey, Inc.")
Uniqueness
One OCN = One carrier entity
Names may have variations
Stability
Rarely changes
Can change with rebranding
Best for
Database keys, joins, matching
User display, reporting
Practical usage:
Use OCN for programmatic matching: If you're joining with other datasets or building database relationships, OCN is more reliable than name matching
Use Company Name for display: Show the readable name to end users in reports and interfaces
Index both fields: OCN for exact lookups, Company for text searches
Example: Verizon has multiple OCNs for different regions (9206 for New Jersey, 9740 for Pennsylvania). OCN distinguishes these entities while company names might appear similar.
Every purchase includes all three formats at no additional cost:
CSV (Comma-Separated Values): Universal format compatible with virtually any application. Perfect for importing into databases, spreadsheets, or custom applications. Standard: 19MB (~3MB compressed). Deluxe: 110MB (~9.5MB compressed).
TAB (Tab-Delimited): Alternative delimiter format useful when data contains commas. Same size as CSV.
PostgreSQL: Use COPY command for efficient bulk loading
SQL Server: Use BULK INSERT or Import/Export Wizard
Oracle: Use SQL*Loader or external tables
SQLite: Use .import command
All formats contain identical data-choose based on your import workflow and tooling preferences. Download all three formats if you want flexibility.
Yes! For validation of area code + exchange (first 6 digits), this database is perfect. Simply extract the first 6 digits (NPA-NXX) from any phone number and look it up.
What you can validate:
Format validity: Is this a valid NPA-NXX combination?
Geographic location: What state/city does this number belong to?
Service type: Is it likely wireless or landline? (Deluxe only)
Carrier information: Which carrier owns this block? (Deluxe only)
Time zone: What time zone is this number in? (Deluxe only)
Assignment status: Is this an active or retired block? (Deluxe only)
Validation example:
Phone: (212) 555-1234
Extract: 212555
Lookup: NPA=212, NXX=555
Result: Valid block, New York City, Landline, Verizon
Important limitations:
This validates the block assignment, not individual number activation
Just because an NPA-NXX exists doesn't mean every number in that block is active
For line-level validation ("is 212-555-1234 currently working?"), you need real-time carrier lookup services
Performance: With proper database indexing on NPANXX or (NPA, NXX) columns, lookups complete in milliseconds. Perfect for real-time validation in web forms or batch processing millions of records.
Yes! Our data works with any system that can import CSV, TAB, or MDB files. The data is normalized, consistently formatted, and ready for production use.
Common integration patterns:
Direct database import: Load into MySQL, PostgreSQL, SQL Server, Oracle, or any SQL-compatible database
CRM enrichment: Append carrier and location data to existing customer phone number records via JOIN on extracted NPA-NXX
API wrapper: Import into your database and expose via REST API for application consumption
ETL pipelines: Use tools like Talend, Informatica, Apache Airflow, or custom scripts for automated quarterly updates
Spreadsheet analysis: Import CSV directly into Excel or Google Sheets for ad-hoc analysis
Integration example (SQL):
-- Enrich customer table with area code data
UPDATE customers c
JOIN npanxx n ON SUBSTRING(c.phone, 1, 6) = n.NPANXX
SET c.phone_state = n.State,
c.phone_timezone = n.TimeZone,
c.phone_carrier = n.Company;
Implementation time: Most customers complete initial integration in under a day. The standardized format eliminates parsing complexity.
Bonus: Many customers combine our Area Code Database with our ZIP Code Database for complete geographic and demographic intelligence-join on the ZIP code field to enrich phone data with Census information and precise coordinates.
We offer two update delivery methods for your convenience:
1. Automated FTP/SFTP/FTPS (Recommended for production):
Free access provided to all customers-just email us your preferred username
Files published mid-quarter (January, April, July, October)
Set up scheduled tasks/cron jobs to download and import automatically
Best practice: Schedule imports for a few days after the typical release window to ensure you capture the final version
Ideal for development environments or occasional updates
Email notifications sent when new releases are available
Update strategy recommendations:
Full replacement method (recommended): Most customers replace the entire table quarterly. Simplest approach with lowest risk of sync errors. Each release is a complete dataset-not incremental deltas.
Zero-downtime updates: Use database table swapping techniques for production environments:
-- MySQL example
RENAME TABLE
npanxx_active TO npanxx_backup,
npanxx_new TO npanxx_active;
Always keep backups: Retain at least the previous quarter's data before importing new updates
Import tips: Use your database's native CSV import tools (MySQL's LOAD DATA INFILE, PostgreSQL's COPY, SQL Server's BULK INSERT). The CSV format is standardized and imports cleanly into all major databases. Index on NPANXX, NPA, NXX, State, and ZipCode fields for optimal query performance.
It depends on how you're using the data:
Standard subscription is sufficient if you're:
Using the data internally within your company
Building applications for your own use
Providing services to clients where the data remains on your servers
Creating internal tools, reports, or analytics
You need a redistribution license if you're:
Embedding data in commercial software that you sell or distribute to customers
Providing the raw data files to clients or partners
Building SaaS applications where customers can download or export the data
Reselling or sublicensing the data in any form
Including data in mobile apps distributed via app stores
Redistribution license benefits:
Unlimited royalty-free distribution within your products
Data must be encrypted or embedded (no raw CSV/TAB/MDB distribution)
1-year term, renewable annually
Standard: $1,249.95/yr | Deluxe: $2,249.95/yr
Still unsure?Contact us with your use case-we'll help determine which license type you need. We want you to use the data confidently and compliantly.
We offer a 30-day, no-questions-asked money-back guarantee. If the data doesn't meet your needs for any reason, just contact us within 30 days of purchase for a full refund.
Why we're confident offering this:
Our data is derived from official NANPA sources-the same data carriers use
23 years in business serving Fortune 500 companies and developers
Transparent data explorer lets you examine actual records before purchasing
Comprehensive documentation so you know exactly what you're getting
No risk, no hassle. We stand behind our data quality because we know it works. Try it risk-free and see for yourself why thousands of customers trust ZIP-Codes.com for their telecom data needs.
While NANPA provides raw assignment files for free, our database offers production-ready enhancements that save you significant time and effort:
Feature
Free NANPA Files
Our Database
Data Format
Pipe-delimited text files requiring custom parsing
Clean CSV, TAB, and MDB formats-import in minutes
ZIP Code Correlations
Not provided
ZIP code matching with frequency rankings and population data
Geographic Enrichments
Basic assignment data only
Coordinates, time zones, DST flags, county data, MSA/CBSA mapping (Deluxe)
Maintenance
You download, process, normalize, and QA every quarter
We handle all updates, corrections, quality assurance, and formatting
Data Cleaning
Raw data with inconsistencies
Normalized, validated, and production-ready
Historical Tracking
Current snapshot only
Status tracking (Active/Inactive), version history, change documentation
Time savings: Most customers report saving 8-12 hours per quarter compared to processing NANPA files manually. That's parsing pipe-delimited formats, handling encoding issues, normalizing carrier names, adding geographic references, validating data integrity, and building import scripts.
The bottom line: NANPA data is authoritative, but it's raw infrastructure data designed for carriers, not developers. We transform it into production-ready intelligence with the enrichments and formatting your applications actually need.
Your choice: Spend hours every quarter wrestling with government data formats, or spend $249-$449 annually and focus on building your application. Explore our live data to see the difference.
Decades of Trust: we're the ZIP Code data experts
Twenty-three years of doing one thing, and the same two
people still answering the phone.
Our Experts
Eddie Harris
Lead Data Architect - 23 Years Experience
Area code data isn't static — NPA splits, overlays, and number-pool reassignments happen multiple times a year. Eddie and our team track every NANPA bulletin and FCC filing, then cross-validate against carrier rate-center records before each release. A bot scraping a Wikipedia page won't catch a planned 2026 overlay before it goes live; we will.
When a rate center swaps carriers or an NPA boundary shifts mid-year, we trace each NXX prefix back to source and confirm jurisdiction. That's the work behind the dataset.
Our mission with area code data: give your call-routing, fraud-detection, and territory-mapping systems the NPA-NXX precision they need — including the planned splits, overlays, and rate-center changes that are about to happen, not just what shipped last quarter.
Since 2003 we've followed NANPA bulletins, FCC rulings, and individual carrier rate-center filings. Every quarterly release is reconciled against active carrier data so the geographic centroid of NPA 415 reflects what your callers actually see today, not the 2010 boundary.
When you're integrating area-code data into a phone system, a CRM, or a regulatory compliance flow, the wrong NXX-to-location mapping is a real operational problem. When you call us about it, you'll reach someone who knows what an OCN is, not a chatbot reading a help article.
from 76+ verified reviews on our Google Business profile
★★★★★
"I was CTO of BankMobile in 2016, and I used zip-codes.com as trusted consumer data. Before that, Clipper Magazine, zip-codes.com data powering home delivery. I was CTO of ScheduleEngine - home services tech - we trusted Zip-Codes.com. RevDial, and new HVAC tech? All zip-codes.com. Nearly my entire professional life, I've had ONE source for the best zip data - zip-codes.com from Datasheer."
Kirk BarrettLocal Guide · 20 reviews
December 2025
★★★★★
"I've used their zip-codes.com data for over 15 years. It's a simple product, nothing fancy. But I like the methodology for rolling up to zip codes. I think it's straightforward and explainable if you need to give an explanation to…"
Scott PorterLocal Guide · 11 reviews
August 2025
★★★★★
"I have used the zip code and zip+4 data from zip-codes.com for about 18 years at 3 different companies. I've never had any issues with the data and count on it to stay up to date with the latest data from USPS."
Bruce Sherman
September 2025
★★★★★
"The zip code data that they have been providing has been invaluable in our analysis of geography and markets. They are always up-to-date and easy to work with."
Joel BuhrLocal Guide · 15 reviews
January 2026
★★★★★
"Lowest cost source of high-quality ZIP Code databases out there, with more data than USPS provides (easier to use too). Using their data has increased our profits from one of our products by an order of magnitude."
Skylar IttnerLocal Guide · 21 reviews
December 2025
★★★★★
"We have been successfully using Datasheer and Zip-codes.com for many years. Their data is authoritative, reliable, and timely with monthly updates. The premium database we use covers a broad range of topics valuable to any business. Highly recommended!"
William Hughes
June 2025
★★★★★
"AWIS uses the monthly zip-code updates to keep our clients current on the latest available zip-codes across the USA.…"
Karl Harker
October 2025
★★★★★
"My place of business uses ZipCodes.com as a critical component of our zip code management. The updates are timely and easy to work with, and the subscription costs are favorable. Highly recommended!"
Marc ThomsonLocal Guide · 40 reviews
June 2025
★★★★★
"We have been subscribing to a variety of master files from Datasheer for many years. The data is always delivered in a timely manner and the support is phenomenal if any questions arise. highly recommend them to anyone looking for what they offer."
Erich KaiserLocal Guide · 91 reviews
June 2025
★★★★★
"My business is using US ZIP Code Database for more than 6 years. It is very useful and the data base is up to date. I have been very pleased with your company and your product over the years. It is very useful for my business."
Joseph Job
November 2025
★★★★★
"I have use Zip-Codes.com standard zip code data base for many years. I use it to convert zip code to longitude/latitude for weather forecast lookups. The price is very reasonable, and the monthly updates keeps my data current. I have…"
Rick Haltermon
June 2025
★★★★★
"Postal code lists help us maintain our database. Simple, comprehensive, and easy to use." (Translated by Google from French)
Sylvain HotteLocal Guide · 19 reviews
April 2026
★★★★★
"We use Datasheer's zip-codes.com database monthly for both U.S. and Canada ZIP/postal code data, and it's been a great resource for our team. The downloads are easy to work with since they come in ZIP files with both XLS and SQL formats,…"
Kevin Tovar
May 2026
★★★★★
"I researched vendors several years ago and Datasheer met all of my needs. I have reached out to customer service several times over the years and received a prompt reply each time. I am a very satisfied customer."
Stacy Meister
May 2026
★★★★★
"We have used Zip-codes.com for US and Canadian zip code data for several years. The data is reliable and reasonably priced and it has been a huge help to our business for several different reporting purposes."
Where every column comes from, and what we do to it
before it reaches you.
Our sources include trusted federal data from NANPA (North American Numbering Plan Administration), USPS ZIP Code data, Canada Post postal code data, and proprietary data enhancements created by ZIP-Codes.com. Data last updated on June23, 2026.
NANPA - North American Numbering Plan Administration [Last Updated: June2026], https://www.nanpa.com
Central Office Code (NPA-NXX) Assignment Records [Quarterly Updates]
Operating Company Number (OCN) and carrier attribution data
Rate center assignments and Local Access Transport Area (LATA) definitions
Area code overlay and split tracking information
United States Postal Service (USPS) [Updated: As Released], https://www.usps.com
ZIP Code™ geographic boundary data and state assignments
Official ZIP Code definitions for NPA-NXX correlation analysis
ZIP code correlation analysis with frequency rankings and population weighting
Geocoding coordinates (latitude/longitude) validated from multiple authoritative sources
Time zone assignments and daylight saving time (DST) observance tracking
Wireless/Landline classification validation and historical status tracking
Data normalization, cross-reference validation, and quality assurance processing
Continuous accuracy improvements based on NANPA updates and customer feedback
NANPA data. NPA-NXX assignment data is derived from official NANPA (North American Numbering Plan Administration) records. NANPA is responsible for the administration and assignment of area codes and central office codes throughout the North American Numbering Plan. This database is independently compiled and is not affiliated with or endorsed by NANPA.
USPS data. ZIP Code™ is a trademark of the United States Postal Service. ZIP Code correlation data is derived from publicly available USPS geographic information.
Canada Post data. Postal Code™ is a trademark of Canada Post Corporation. Canadian reference data is used in accordance with applicable licensing terms.
Terms of Service
Loading Terms of Service...
Area Code DatabaseDeluxe
For internal use
Use within your organization for business operations, analysis, and internal tools.
