ISO 3166 Country Codes Reference - Complete List

ISO 3166 country codes are standardized codes used to represent countries and territories worldwide. This comprehensive guide covers alpha-2, alpha-3, and numeric codes essential for international web development, APIs, and e-commerce.

Table of Contents

1. What Are ISO 3166 Country Codes?
2. Types of Country Codes
3. Most Common Country Codes
4. Using Country Codes in Development
5. Country Codes for APIs
6. Complete Country List
7. Best Practices

What Are ISO 3166 Country Codes?

ISO 3166 is an international standard for country codes maintained by the International Organization for Standardization (ISO). These codes are used worldwide for:

• E-commerce: Shipping addresses, tax calculations
• APIs: Location data, payment processing
• Forms: Country selection dropdowns
• Databases: Storing nationality, location
• Analytics: Geographic reporting
• Localization: Language and region settings

Types of Country Codes

ISO 3166 provides three different code formats for each country:

Alpha-2 Codes (2-Letter)

Format: Two uppercase letters
Example: US, GB, CA

Most commonly used for:

• Top-level domains (.us, .uk, .ca)
• Language tags (en-US, en-GB)
• Currency codes prefix
• Most APIs and databases

// Most common usage
const country = 'US';  // United States
const locale = 'en-US';  // English (United States)
const domain = 'example.us';

Alpha-3 Codes (3-Letter)

Format: Three uppercase letters
Example: USA, GBR, CAN

Most commonly used for:

• Vehicle registration plates
• Currency codes (ISO 4217)
• International shipping
• Some government systems

// Alpha-3 usage
const country = 'USA';  // United States
const currencyCode = 'USD';  // Starts with country alpha-3

Numeric Codes (3-Digit)

Format: Three digits (with leading zeros)
Example: 840, 826, 124

Most commonly used for:

• Systems that don't support Latin characters
• UN statistics
• International databases
• Some payment systems

// Numeric usage
const country = '840';  // United States
const countryCode = 840;  // As integer

Most Common Country Codes

Top 20 Countries by Population

View United States (US) | View China (CN) | View India (IN)

Major English-Speaking Countries

European Union Countries

Using Country Codes in Development

HTML Country Select Dropdown

<select name="country" id="country">
  <option value="">Select a country...</option>
  <option value="US">United States</option>
  <option value="GB">United Kingdom</option>
  <option value="CA">Canada</option>
  <option value="AU">Australia</option>
  <option value="DE">Germany</option>
  <option value="FR">France</option>
  <option value="JP">Japan</option>
  <option value="CN">China</option>
  <!-- ... more countries -->
</select>

JavaScript Country Data Structure

const countries = [
  {
    name: 'United States',
    alpha2: 'US',
    alpha3: 'USA',
    numeric: '840',
    currency: 'USD',
    languages: ['en'],
    flag: '🇺🇸'
  },
  {
    name: 'United Kingdom',
    alpha2: 'GB',
    alpha3: 'GBR',
    numeric: '826',
    currency: 'GBP',
    languages: ['en'],
    flag: '🇬🇧'
  },
  {
    name: 'Germany',
    alpha2: 'DE',
    alpha3: 'DEU',
    numeric: '276',
    currency: 'EUR',
    languages: ['de'],
    flag: '🇩🇪'
  }
  // ... more countries
];

// Usage
function getCountryByCode(alpha2Code) {
  return countries.find(c => c.alpha2 === alpha2Code);
}

const country = getCountryByCode('US');
console.log(country.name);  // "United States"
console.log(country.currency);  // "USD"

TypeScript Interface

interface Country {
  name: string;
  alpha2: string;
  alpha3: string;
  numeric: string;
  currency: string;
  languages: string[];
  flag: string;
  continent?: string;
  region?: string;
}

const country: Country = {
  name: 'United States',
  alpha2: 'US',
  alpha3: 'USA',
  numeric: '840',
  currency: 'USD',
  languages: ['en'],
  flag: '🇺🇸',
  continent: 'North America',
  region: 'Americas'
};

React Country Selector Component

import { useState } from 'react';

const countries = [
  { code: 'US', name: 'United States', flag: '🇺🇸' },
  { code: 'GB', name: 'United Kingdom', flag: '🇬🇧' },
  { code: 'CA', name: 'Canada', flag: '🇨🇦' },
  // ... more countries
];

function CountrySelector({ value, onChange }) {
  return (
    <select 
      value={value} 
      onChange={(e) => onChange(e.target.value)}
      className="country-selector"
    >
      <option value="">Select a country...</option>
      {countries.map(country => (
        <option key={country.code} value={country.code}>
          {country.flag} {country.name}
        </option>
      ))}
    </select>
  );
}

// Usage
function ShippingForm() {
  const [country, setCountry] = useState('');
  
  return (
    <div>
      <label>Country:</label>
      <CountrySelector value={country} onChange={setCountry} />
      {country && <p>Selected: {country}</p>}
    </div>
  );
}

Searchable Country Dropdown

function createSearchableCountryDropdown(countries, inputId, listId) {
  const input = document.getElementById(inputId);
  const list = document.getElementById(listId);
  
  input.addEventListener('input', (e) => {
    const searchTerm = e.target.value.toLowerCase();
    const filtered = countries.filter(country => 
      country.name.toLowerCase().includes(searchTerm) ||
      country.alpha2.toLowerCase().includes(searchTerm)
    );
    
    list.innerHTML = filtered
      .map(country => \`
        <div class="country-option" data-code="\${country.alpha2}">
          <span class="flag">\${country.flag}</span>
          <span class="name">\${country.name}</span>
          <span class="code">\${country.alpha2}</span>
        </div>
      \`)
      .join('');
  });
  
  list.addEventListener('click', (e) => {
    const option = e.target.closest('.country-option');
    if (option) {
      const code = option.dataset.code;
      input.value = option.querySelector('.name').textContent;
      input.dataset.countryCode = code;
      list.style.display = 'none';
    }
  });
}

Country Codes for APIs

REST API Examples

// Get user location by country code
GET /api/users?country=US

// Filter products by country
GET /api/products?shipping_country=GB

// Get country information
GET /api/countries/US

// Response
{
  "alpha2": "US",
  "alpha3": "USA",
  "numeric": "840",
  "name": "United States",
  "currency": "USD",
  "languages": ["en"],
  "region": "Americas"
}

Payment Processing

// Stripe payment intent with country
const paymentIntent = await stripe.paymentIntents.create({
  amount: 1000,
  currency: 'usd',
  payment_method_types: ['card'],
  shipping: {
    name: 'John Doe',
    address: {
      line1: '123 Main St',
      city: 'New York',
      state: 'NY',
      postal_code: '10001',
      country: 'US'  // ISO 3166 alpha-2 code
    }
  }
});

// PayPal
{
  "payer": {
    "address": {
      "country_code": "US"  // ISO 3166 alpha-2 code
    }
  }
}

Shipping APIs

// FedEx, UPS, DHL typically use alpha-2 codes
const shipment = {
  origin: {
    country: 'US',
    city: 'New York',
    zip: '10001'
  },
  destination: {
    country: 'GB',
    city: 'London',
    zip: 'SW1A 1AA'
  }
};

// Calculate shipping rates
fetch('/api/shipping/rates', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify(shipment)
});

Geolocation APIs

// IP Geolocation
const response = await fetch('https://ipapi.co/json/');
const data = await response.json();
console.log(data.country_code);  // "US"
console.log(data.country_name);  // "United States"

// Google Maps Geocoding API
{
  "address_components": [
    {
      "long_name": "United States",
      "short_name": "US",  // ISO 3166-1 alpha-2
      "types": ["country", "political"]
    }
  ]
}

Complete Country List

A-D

View full list →

E-I

J-P

Q-Z

Best Practices

1. Always Use Alpha-2 Codes

// ✅ Good - Use alpha-2 (most standard)
const country = 'US';
const locale = 'en-US';

// ❌ Avoid - Using full names
const country = 'United States';  // Ambiguous, translation issues

// ❌ Avoid - Using numeric codes
const country = 840;  // Less readable, harder to maintain

2. Validate Country Codes

const validCountryCodes = new Set([
  'US', 'GB', 'CA', 'AU', 'DE', 'FR', 'JP', // ... all valid codes
]);

function isValidCountryCode(code) {
  return validCountryCodes.has(code.toUpperCase());
}

// Usage
if (!isValidCountryCode(userInput)) {
  throw new Error('Invalid country code');
}

3. Store Codes, Display Names

// ✅ Good - Store code in database
{
  "user_id": 123,
  "country": "US",  // Store code
  "created_at": "2025-01-15"
}

// Display full name in UI
const countryNames = {
  'US': 'United States',
  'GB': 'United Kingdom',
  'CA': 'Canada'
};

function displayCountry(code) {
  return countryNames[code] || code;
}

4. Handle Special Cases

// UK vs GB
function normalizeCountryCode(code) {
  const normalized = code.toUpperCase();
  
  // Handle common variations
  if (normalized === 'UK') return 'GB';  // UK → GB
  if (normalized === 'USA') return 'US';  // USA → US (if expecting alpha-2)
  
  return normalized;
}

// Usage
const country = normalizeCountryCode('UK');  // Returns 'GB'

5. Consider User Location

// Auto-detect user's country
async function detectUserCountry() {
  try {
    const response = await fetch('https://ipapi.co/json/');
    const data = await response.json();
    return data.country_code;  // e.g., 'US'
  } catch (error) {
    return 'US';  // Default fallback
  }
}

// Pre-select in form
const userCountry = await detectUserCountry();
document.getElementById('country').value = userCountry;

6. Localization

// Display country names in user's language
const countryNames = {
  en: {
    'US': 'United States',
    'FR': 'France',
    'DE': 'Germany'
  },
  es: {
    'US': 'Estados Unidos',
    'FR': 'Francia',
    'DE': 'Alemania'
  },
  fr: {
    'US': 'États-Unis',
    'FR': 'France',
    'DE': 'Allemagne'
  }
};

function getCountryName(code, language = 'en') {
  return countryNames[language]?.[code] || code;
}

console.log(getCountryName('US', 'es'));  // "Estados Unidos"

Common Issues and Solutions

Issue 1: UK vs GB

// Always normalize
function getOfficialCode(code) {
  return code === 'UK' ? 'GB' : code;
}

Issue 2: Country Name Changes

Countries occasionally change names or codes. Examples:

• Swaziland → Eswatini (SZ remains the same)
• Macedonia → North Macedonia (MK remains the same)
• Burma/Myanmar (both MM used)

Solution: Keep your country list updated and use codes, not names.

Issue 3: Disputed Territories

Some territories have codes but may not be universally recognized:

• Taiwan (TW) - Recognized by ISO but politically complex
• Palestine (PS) - Observer state
• Kosovo (XK) - Temporary code

Solution: Be aware of your target audience and handle sensitively.

Summary

ISO 3166 country codes are essential for international web development. Always use alpha-2 codes for consistency, validate user input, and keep your country data updated.

Key Takeaways:

✅ Use alpha-2 codes (US, GB, CA) for most applications
✅ Store codes in database, display full names in UI
✅ Always validate country codes against official list
✅ Use GB for United Kingdom, not UK
✅ Consider localization for country names
✅ Auto-detect user's country when possible
✅ Keep country data updated with ISO changes

Related Guides

• Currency Codes (ISO 4217)
• Language Codes (ISO 639)
• Timezone Codes
• Browse All Country Codes →