Mexican Banking Reference

This reference guide provides essential information about the Mexican banking system, including institution codes, CLABE validation, RFC formats, and SPEI operating schedules. This information is crucial for implementing SPEI transfers and withdrawals in Mexico.

Institution Codes

Major Mexican financial institutions and their corresponding codes for SPEI transactions:

Code	Bank Name	CLABE Prefix	Type
40012	BBVA México	012	Commercial Bank
40014	Santander	014	Commercial Bank
40021	HSBC	021	Commercial Bank
40072	Banorte	072	Commercial Bank
40646	STP	646	Payment Institution
40137	Banregio	137	Commercial Bank
40058	Banco Azteca	058	Commercial Bank
40030	Bajío	030	Commercial Bank
40036	Inbursa	036	Commercial Bank
40042	Mifel	042	Commercial Bank
40060	Bansi	060	Commercial Bank
40102	The Royal Bank	102	Foreign Bank
40103	American Express	103	Credit Card Company
40106	Bank of America	106	Foreign Bank
40108	JP Morgan	108	Foreign Bank
40110	Credit Suisse	110	Foreign Bank
40124	Deutsche Bank	124	Foreign Bank
40126	Credit Agricole	126	Foreign Bank
40127	Azteca	127	Commercial Bank
40128	Autofin	128	Development Bank
40129	Barclays	129	Foreign Bank
40130	Compartamos	130	Development Bank
40131	Banco Famsa	131	Commercial Bank
40132	BMULTIVA	132	Brokerage
40133	ACTINVER	133	Brokerage
40135	NAF	135	Development Bank
40136	Intercam Banco	136	Commercial Bank
40138	Intercam	138	Brokerage
40139	Bancoppel	139	Commercial Bank
40140	ABC Capital	140	Brokerage
40141	UBS Bank	141	Foreign Bank
40143	CIBanco	143	Commercial Bank
40145	Bbase	145	Commercial Bank
40147	Bankaool	147	Commercial Bank
40148	Pagatodo	148	Payment Institution
40150	Inmobiliario	150	Development Bank
40151	Donde	151	Payment Institution
40152	Bancrea	152	Commercial Bank

CLABE Validation

CLABE (Clave Bancaria Estandarizada) is Mexico’s standardized bank account number format used for SPEI transfers.

CLABE Format Structure

Total length: 18 digits
Bank code: 3 digits (positions 1-3)
Branch code: 3 digits (positions 4-6)
Account number: 11 digits (positions 7-17)
Check digit: 1 digit (position 18)

Example CLABE Breakdown:

CLABE: 012345678901234567
│││└─────────────────── Account number (11 digits)
││└─────────────────────── Branch code (3 digits)
│└──────────────────────── Bank code (3 digits)
└───────────────────────── Check digit (1 digit)

Where:

012: BBVA México bank code
345: Branch code (specific branch)
67890123456: Account number (11 digits)
7: Check digit (calculated using algorithm)

CLABE Validation Algorithm

The check digit is calculated using a weighted sum algorithm:

def validate_clabe(clabe):
    """Validate CLABE number using check digit algorithm"""
    
    if len(clabe) != 18 or not clabe.isdigit():
        return False
    
    # Weights for positions 1-17
    weights = [3, 7, 1, 3, 7, 1, 3, 7, 1, 3, 7, 1, 3, 7, 1, 3, 7]
    
    # Calculate weighted sum
    weighted_sum = sum(int(clabe[i]) * weights[i] for i in range(17))
    
    # Calculate check digit
    remainder = weighted_sum % 10
    calculated_check_digit = (10 - remainder) % 10
    
    # Compare with actual check digit
    actual_check_digit = int(clabe[17])
    
    return calculated_check_digit == actual_check_digit

# Example usage
clabe = "012345678901234567"
is_valid = validate_clabe(clabe)
print(f"CLABE {clabe} is {'valid' if is_valid else 'invalid'}")

CLABE Components Extraction

The code block below shows how to parse the CLABE into its components.

Python Implementation

def parse_clabe(clabe):
    """Parse CLABE into its components"""
    
    if not validate_clabe(clabe):
        raise ValueError("Invalid CLABE format")
    
    return {
        'bank_code': clabe[:3],
        'branch_code': clabe[3:6],
        'account_number': clabe[6:17],
        'check_digit': clabe[17],
        'full_clabe': clabe
    }

# Example
clabe_parts = parse_clabe("012345678901234567")
print(f"Bank: {clabe_parts['bank_code']}")
print(f"Branch: {clabe_parts['branch_code']}")
print(f"Account: {clabe_parts['account_number']}")

RFC (Tax ID) Format

RFC (Registro Federal de Contribuyentes) is Mexico’s tax identification system.

RFC Format Types

Type	Length	Structure	Pattern	Example
Individual	13	4 letters + 6 digits + 3 alphanumeric characters	`^[A-Z&Ñ]{4}\\d{6}[A-Z\\d]{3}$`	`MAGR850920XY1`
Business	12	3 letters + 6 digits + 3 alphanumeric characters	`^[A-Z&Ñ]{3}\\d{6}[A-Z\\d]{3}$`	`ABC850920123`

RFC Format Breakdown

Type	Letters Part	Digits Part	Verification Part	Description
Individual	MAGR	850920	XY1	Name-derived letters + birth date + verification code
Business	ABC	850920	123	Business name-derived letters + registration date + verification code

RFC Validation

Here is an example of how to validate the RFC format.

Python Implementation

import re

def validate_rfc(rfc):
    """Validate Mexican RFC format"""
    
    if not rfc or len(rfc) < 12 or len(rfc) > 13:
        return False
    
    # Remove spaces and convert to uppercase
    rfc = rfc.replace(' ', '').upper()
    
    # Patterns for validation
    individual_pattern = r'^[A-Z&Ñ]{4}\d{6}[A-Z\d]{3}$'
    business_pattern = r'^[A-Z&Ñ]{3}\d{6}[A-Z\d]{3}$'
    
    # Check if it matches either pattern
    if len(rfc) == 13:
        return re.match(individual_pattern, rfc) is not None
    elif len(rfc) == 12:
        return re.match(business_pattern, rfc) is not None
    
    return False

# Examples
individual_rfc = "MAGR850920XY1"
business_rfc = "ABC850920123"

print(f"Individual RFC {individual_rfc}: {'Valid' if validate_rfc(individual_rfc) else 'Invalid'}")
print(f"Business RFC {business_rfc}: {'Valid' if validate_rfc(business_rfc) else 'Invalid'}")

RFC Type Detection

The code block below shows how to determine the type of RFC.

Python Implementation

def get_rfc_type(rfc):
    """Determine if RFC is for individual or business"""
    
    if not validate_rfc(rfc):
        return None
    
    rfc = rfc.replace(' ', '').upper()
    
    if len(rfc) == 13:
        return 'individual'
    elif len(rfc) == 12:
        return 'business'
    else:
        return None

# Example usage
rfc = "MAGR850920XY1"
rfc_type = get_rfc_type(rfc)
print(f"RFC {rfc} is for: {rfc_type}")

SPEI Timing and Operational Constraints

SPEI operates with specific timing considerations that affect when transfers can be processed and completed. Understanding these constraints helps ensure reliable payment processing.

Operating Hours

Day/Period	Processing Hours	Notes
Monday to Friday	6:00 AM – 6:00 PM (CDMX time)	Same-day processing if before 5:00 PM
Saturday	9:00 AM – 2:00 PM	Limited processing
Sunday	No processing
Bank holidays	No processing

Processing Times for SPEISPEI generally operates 24/7, but individual institutions may apply maintenance windows or additional validations that can introduce delays. Some banks or payment providers may apply their own internal processing schedules or restrictions.Possible delays may occur due to:

Scheduled maintenance windows
Anti-fraud validations
Institutional batch processing policies

Please verify specific hours or limitations with your financial institution or provider.

Processing Time Examples

Submission Time	Day	Expected Processing Time
10:00 AM	Monday	Same day (within minutes)
4:30 PM	Tuesday	Same day (within minutes)
5:30 PM	Wednesday	Same day (within minutes)
11:00 AM	Saturday	Same day (within minutes)
2:30 PM	Saturday	Same day (within minutes)
10:00 AM	Sunday	Same day (within minutes)

All times are shown in local Mexico City time.
Actual processing times can vary depending on:
- Your bank or fintech provider’s policies
- Internal fraud or compliance checks
- Scheduled maintenance windows

SPEI itself doesn’t enforce business day cut-off times anymore, so in theory, transfers can go through at any hour. However, your provider or bank might still have their own restrictions or delays—so it’s always worth double-checking if you need funds to arrive urgently.

Holiday Calendar

Time Zone Considerations

The code block below shows how to check if SPEI is currently operating.

Python Implementation

from datetime import datetime
import pytz

def is_spei_operating_time(timestamp=None):
    """Check if SPEI is currently operating"""
    
    if timestamp is None:
        timestamp = datetime.now()
    
    # Convert to Mexico City timezone
    mexico_tz = pytz.timezone('America/Mexico_City')
    if timestamp.tzinfo is None:
        timestamp = pytz.utc.localize(timestamp)
    
    mexico_time = timestamp.astimezone(mexico_tz)
    
    # Check day of week (0 = Monday, 6 = Sunday)
    weekday = mexico_time.weekday()
    hour = mexico_time.hour
    
    if weekday < 5:  # Monday to Friday
        return 6 <= hour < 18
    elif weekday == 5:  # Saturday
        return 9 <= hour < 14
    else:  # Sunday
        return False

# Example usage
now = datetime.now(pytz.UTC)
is_operating = is_spei_operating_time(now)
print(f"SPEI is {'operating' if is_operating else 'not operating'} right now")

Bank Account Types

The table below shows the different account types in Mexico.

Code	Type	Description
1	Checking Account	Cuenta de cheques
2	Savings Account	Cuenta de ahorros
3	Credit Account	Cuenta de crédito
40	CLABE Account	Cuenta CLABE (for SPEI)
10	Investment Account	Cuenta de inversión

Usage in WithdrawalsFor SPEI withdrawals, the account type is usually picked up automatically from the CLABE format. However, for some operations, you might need to specify it yourself:

{
  "beneficiary": {
    "account": "012345678901234567",
    "account_type": "40",
    "name": "Roberto Martínez García",
    "rfc": "MAGR850920XY1",
    "institution": "40012"
  }
}

Complete Validation Function

The code block below shows a complete validation function for Mexican banking data.

Python Implementation

def validate_mexican_banking_data(data):
    """Validate all Mexican banking data fields"""
    
    errors = []
    
    # Validate CLABE
    clabe = data.get('clabe', '').replace(' ', '')
    if not validate_clabe(clabe):
        errors.append("Invalid CLABE format")
    
    # Validate RFC
    rfc = data.get('rfc', '')
    if not validate_rfc(rfc):
        errors.append("Invalid RFC format")
    
    # Validate institution code
    institution = data.get('institution', '')
    valid_institutions = ['40012', '40014', '40021', '40072', '40646', '40137', '40058']
    if institution not in valid_institutions:
        errors.append("Invalid institution code")
    
    # Cross-validate CLABE and institution
    if clabe and institution:
        clabe_bank_code = clabe[:3]
        institution_suffix = institution[2:] if len(institution) == 5 else institution
        if clabe_bank_code != institution_suffix:
            errors.append("CLABE bank code doesn't match institution code")
    
    return {
        'valid': len(errors) == 0,
        'errors': errors
    }

# Example usage
banking_data = {
    'clabe': '012345678901234567',
    'rfc': 'MAGR850920XY1',
    'institution': '40012'
}

validation_result = validate_mexican_banking_data(banking_data)
if validation_result['valid']:
    print("All banking data is valid")
else:
    print("Validation errors:", validation_result['errors'])

Common Implementation Patterns

Expand the items below to see the code for some common implementation patterns.

CLABE Formatting for Display

def format_clabe_for_display(clabe):
    """Format CLABE for user-friendly display"""
    
    if len(clabe) != 18:
        return clabe
    
    # Format as: 012 345 67890123456 7
    return f"{clabe[:3]} {clabe[3:6]} {clabe[6:17]} {clabe[17]}"

# Example
clabe = "012345678901234567"
formatted = format_clabe_for_display(clabe)
print(f"Formatted CLABE: {formatted}")

Account Masking for Security

def mask_account_number(clabe):
    """Mask CLABE for security display"""
    
    if len(clabe) != 18:
        return clabe
    
    # Show first 3 and last 4 digits
    return f"{clabe[:3]}***********{clabe[-4:]}"

# Example
clabe = "012345678901234567"
masked = mask_account_number(clabe)
print(f"Masked CLABE: {masked}")

Error Messages

The table below shows the error messages for Mexican banking data.

Error Code	English Message
`invalid_clabe`	CLABE must be exactly 18 digits with valid checksum
`invalid_clabe_checksum`	CLABE checksum is invalid
`invalid_rfc`	RFC format is invalid (must be 12-13 alphanumeric characters)
`invalid_institution`	Institution code not found in Mexican banking system
`clabe_institution_mismatch`	CLABE bank code does not match institution code
`spei_not_operating`	SPEI transfers are not processed outside business hours
`invalid_account_type`	Account type must be valid for SPEI transfers

You can use the code block below to get the error message for a given error code.

MEXICAN_BANKING_ERRORS = {
    'invalid_clabe': 'CLABE must be exactly 18 digits with valid checksum',
    'invalid_clabe_checksum': 'CLABE checksum is invalid',
    'invalid_rfc': 'RFC format is invalid (must be 12-13 alphanumeric characters)',
    'invalid_institution': 'Institution code not found in Mexican banking system',
    'clabe_institution_mismatch': 'CLABE bank code does not match institution code',
    'spei_not_operating': 'SPEI transfers are not processed outside business hours',
    'invalid_account_type': 'Account type must be valid for SPEI transfers'
}

def get_error_message(error_code, lang='en'):
    """Get localized error message"""
    
    spanish_messages = {
        'invalid_clabe': 'CLABE debe tener exactamente 18 dígitos con suma de verificación válida',
        'invalid_rfc': 'Formato de RFC inválido (debe tener 12-13 caracteres alfanuméricos)',
        'spei_not_operating': 'Las transferencias SPEI no se procesan fuera del horario bancario'
    }
    
    if lang == 'es' and error_code in spanish_messages:
        return spanish_messages[error_code]
    
    return MEXICAN_BANKING_ERRORS.get(error_code, 'Unknown banking error')

Next Steps

Payment Methods – Details on implementing SPEI and other payment options
Withdrawals – How to process withdrawals with Mexican banks
Error Handling – Common banking validation errors and solutions
Production Readiness – Compliance and operational requirements for going live

Getting Started

API Reference

Payment Processing

Integration

Regional Reference

Resources

Mexican Banking Reference

Institution Codes

CLABE Validation

CLABE Format Structure

CLABE Validation Algorithm

CLABE Components Extraction

RFC (Tax ID) Format

RFC Format Types

RFC Format Breakdown

RFC Validation

RFC Type Detection

SPEI Timing and Operational Constraints

Bank Account Types

Complete Validation Function

Common Implementation Patterns

Error Messages

Next Steps

Getting Started

API Reference

Payment Processing

Integration

Regional Reference

Resources

​Institution Codes

​CLABE Validation

​CLABE Format Structure

​CLABE Validation Algorithm

​CLABE Components Extraction

​RFC (Tax ID) Format

​RFC Format Types

​RFC Format Breakdown

​RFC Validation

​RFC Type Detection

​SPEI Timing and Operational Constraints

​Bank Account Types

​Complete Validation Function

​Common Implementation Patterns

​Error Messages

​Next Steps

Institution Codes

CLABE Validation

CLABE Format Structure

CLABE Validation Algorithm

CLABE Components Extraction

RFC (Tax ID) Format

RFC Format Types

RFC Format Breakdown

RFC Validation

RFC Type Detection

SPEI Timing and Operational Constraints

Bank Account Types

Complete Validation Function

Common Implementation Patterns

Error Messages

Next Steps