How to Validate EU VAT Numbers in Python

1. The problem with EU VAT validation

At first glance, validating a VAT number in a Python app seems trivial — just check the format, right? But EU VAT numbers span 27 member states, each with its own structure, length, character set, and checksum algorithm. And format validation is only half the story: a number that looks correct might still be unregistered, suspended, or belong to a dissolved company.

If your app invoices B2B customers in Europe, incorrect VAT handling carries real tax liability. This guide walks through the failure modes and the practical solution.

2. The EU VAT number regex — and why it fails for all 27 countries

The first thing most developers try is a simple regex. Something like this:

# DO NOT USE — this will reject valid VAT numbers
import re

EU_VAT_REGEX = re.compile(
    r"^(AT|BE|BG|HR|CY|CZ|DK|EE|FI|FR|DE|EL|HU|IE|IT|LV|LT|LU|MT|NL|PL|PT|RO|SK|SI|ES|SE)"
    r"[0-9A-Z]{8,12}$"
)

def validate_vat(vat: str) -> bool:
    return bool(EU_VAT_REGEX.match(vat.upper().replace(" ", "")))

validate_vat("DE123456788")    # True   (but might not exist)
validate_vat("FR12345678801")  # False  (actually valid — FR allows letters!)
validate_vat("EL123456788")    # False  (Greece uses EL, not GR)
validate_vat("IE1234567FA")    # False  (Ireland's format: digit + 5 digits + 2 letters)

To handle all EU countries correctly, you'd need 27 separate regexes — plus checksum verification logic for many of them (Germany, Poland, Italy, Spain, etc. all use country-specific check digit algorithms).

3. Why VAT validation is genuinely hard

4. The right solution: one API call

Instead of maintaining 27 country-specific validators plus VIES integration, use the IsValid VAT API. A single GET request handles format validation, checksum verification, and optional VIES lookup — for 60+ countries.

Get your free API key at isvalid.dev. The free tier includes 100 calls per day — enough for most development and low-volume production use.

Full parameter reference and response schema: VAT Validation API docs →

5. Python code example

Using the isvalid-sdk Python SDK or the requests library. Install with pip install isvalid-sdk or pip install requests.

# vat_validator.py
import os
from isvalid_sdk import IsValidConfig, create_client

iv = create_client(IsValidConfig(api_key=os.environ["ISVALID_API_KEY"]))

# ── Example usage ────────────────────────────────────────────────────────────

result = iv.vat("DE123456788", check_vies=True, country_code="DE")

if not result["valid"]:
    print("Invalid VAT format or checksum")
elif result.get("vies", {}).get("checked") and not result["vies"]["valid"]:
    print("Format OK, but not found in VIES — may be suspended or not yet registered")
elif result.get("vies", {}).get("checked") and result["vies"]["valid"]:
    print(f"Active EU VAT: {result['vies']['name']}")
else:
    print(f"Format valid — {result['countryName']}")

# app.py (Flask)
from flask import Flask, request, jsonify
from vat_validator import validate_vat

app = Flask(__name__)


@app.post("/checkout")
def checkout():
    data = request.get_json()

    try:
        vat_check = validate_vat(data["vat_number"], check_vies=True)
    except requests.RequestException:
        return jsonify(error="VAT validation service unavailable"), 502

    if not vat_check["valid"]:
        return jsonify(error="Invalid VAT number"), 400

    vies = vat_check.get("vies", {})
    if vies.get("checked") and not vies.get("valid"):
        return jsonify(error="VAT number is not currently registered"), 400

    # Zero-rate VAT for valid intra-EU B2B sale
    apply_vat_exemption(
        vat_number=data["vat_number"],
        company_name=vies.get("name"),
    )

    return jsonify(success=True, vatExempt=True)

# views.py (Django REST Framework)
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from vat_validator import validate_vat
import requests as http_requests


class CheckoutView(APIView):
    def post(self, request):
        vat_number = request.data.get("vat_number")
        if not vat_number:
            return Response(
                {"error": "vat_number is required"},
                status=status.HTTP_400_BAD_REQUEST,
            )

        try:
            vat_check = validate_vat(vat_number, check_vies=True)
        except http_requests.RequestException:
            return Response(
                {"error": "VAT validation service unavailable"},
                status=status.HTTP_502_BAD_GATEWAY,
            )

        if not vat_check["valid"]:
            return Response(
                {"error": "Invalid VAT number"},
                status=status.HTTP_400_BAD_REQUEST,
            )

        return Response({"valid": True, "country": vat_check["countryName"]})

6. cURL example

Format + checksum validation only (fast, no VIES call):

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.isvalid.dev/v0/vat?value=DE123456788"

With VIES registration check (slower — queries EU servers):

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.isvalid.dev/v0/vat?value=DE123456788&checkVies=true"

With explicit country code (useful when the number has no prefix):

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.isvalid.dev/v0/vat?value=123456788&countryCode=DE"

7. Understanding the response

Response for a valid German VAT number with VIES check enabled:

{
  "valid": true,
  "normalized": "123456788",
  "countryCode": "DE",
  "countryName": "Germany",
  "isEU": true,
  "vies": {
    "checked": true,
    "valid": true,
    "name": "EXAMPLE GMBH",
    "address": "MUSTERSTRASSE 1\n10115 BERLIN"
  }
}

When checkVies is omitted or false, the vies field is not included in the response. When VIES is unreachable, vies.checked is false and vies.reason is "unavailable".

8. Edge cases to handle

# Handle suspended / deregistered VAT
vies = result.get("vies", {})
if result["valid"] and vies.get("checked") and not vies.get("valid"):
    # Format OK, but not in VIES — reject or flag for manual review
    raise ValueError("VAT number is not currently registered")

vies = result.get("vies", {})
if vies and not vies.get("checked"):
    reason = vies.get("reason")
    if reason == "unavailable":
        # VIES is temporarily down — do not reject, log and retry later
        logger.warning("VIES unavailable for %s", vat_number)
        return {"valid": result["valid"], "vies_status": "unavailable"}
    if reason == "not_eu":
        # Non-EU country — no VIES check possible, format-only validation
        return {"valid": result["valid"], "vies_status": "not_applicable"}

def validate_vat_safe(
    vat_number: str, **kwargs
) -> dict:
    try:
        return validate_vat(vat_number, **kwargs)
    except requests.RequestException as exc:
        # Log and decide: fail open (allow) or fail closed (reject)
        logger.error("VAT validation failed: %s", exc)
        return {"valid": None, "error": "validation_unavailable"}

Python integration notes

Pydantic V2 makes it straightforward to validate EU VAT Number as part of a data model. Use @field_validator or the Annotated pattern with AfterValidator to call the IsValid API inside the validator and raise aValueError on failure. The validator runs automatically whenever the model is instantiated — in a FastAPI request body, a SQLModel ORM model, or a standalone Pydantic parse. Initialise the API client as a module-level singleton so it is not re-created on every request.

When processing a batch of EU VAT Number values — during a CSV import or a nightly reconciliation job — useasyncio.gather() with a shared httpx.AsyncClientand an asyncio.Semaphoreto cap concurrency at the API rate limit. This brings total validation time from O(n) sequential to O(1) bounded by the pool size.

Handle httpx.HTTPStatusError andhttpx.RequestErrorseparately. A 422 from IsValid means the EU VAT Number is structurally invalid — surface this as a validation error to the user. A 503 or network error means the API is temporarily unavailable — retry with exponential backoff usingtenacity before falling back gracefully.

• Store ISVALID_API_KEY in a .env file and load it with python-dotenv at startup
• Use pytest-asyncio with asyncio_mode = "auto" for testing async validation paths
• Type-annotate validated fields with NewType('VatNumber', str) for clarity in function signatures
• Apply .strip() and .upper() before validation — EU VAT Number values often arrive with stray whitespace or mixed case from user input