Vérifier un freelance néerlandais via l'API KVK

Si votre entreprise travaille avec des freelances néerlandais (zzp’ers), vous avez l’obligation légale de vérifier qu’ils sont réellement indépendants. Depuis 2025, l’administration fiscale néerlandaise (Belastingdienst) applique activement la Wet DBA (loi sur l’évaluation de la déréglementation des relations de travail) : les entreprises qui recourent à des freelances non immatriculés ou mal qualifiés s’exposent à des rappels d’impôt sur les salaires et de cotisations sociales.

La première étape de tout contrôle de conformité zzp est simple : le freelance est-il réellement immatriculé à la chambre de commerce néerlandaise (KVK) ? Avec l’API KVKBase, vous pouvez automatiser ce contrôle et l’intégrer directement à votre parcours d’onboarding fournisseurs.

Pourquoi la vérification KVK compte pour les freelances

Payer la facture de quelqu’un qui n’est pas immatriculé comme entreprise peut être requalifié en relation de travail salarié. Les conséquences sont notamment :

• Rappel d’impôt sur les salaires (loonbelasting)
• Redressement de cotisations de sécurité sociale
• Amendes éventuelles pour non-conformité

Une immatriculation KVK vérifiée ne prouve pas à elle seule le statut légal d’indépendant, mais c’est un socle indispensable. Sans elle, vous êtes déjà sur un terrain juridique incertain.

Ce que renvoie l’API KVKBase

Pour la vérification d’un freelance, voici les champs essentiels :

Champ	Signification
naam	Dénomination enregistrée
rechtsvorm	Forme juridique (Eenmanszaak, BV, VOF, etc.)
actief	Indique si l’entreprise est actuellement active
startdatum	Date d’immatriculation
sbiCode	Classification d’activité
adres	Adresse enregistrée actuelle

Une entreprise individuelle (rechtsvorm: "Eenmanszaak", actief: true) est la structure la plus courante chez les freelances néerlandais.

Mise en œuvre : vérifier un freelance en Python

import os
import requests

API_KEY=os.env..._URL = "https://api.kvkbase.nl/api/v1"

def verify_freelancer(kvk_number: str) -> dict:
    """
    Verify whether a freelancer is actively registered with the KVK.
    Raises HTTPError if the KVK number does not exist.
    """
    response = requests.get(
        f"{BASE_URL}/kvk/{kvk_number}",
        headers={"x-api-key": API_KEY},
        timeout=10,
    )
    response.raise_for_status()
    data = response.json()

    result = {
        "kvk_number": kvk_number,
        "name": data.get("naam"),
        "legal_form": data.get("rechtsvorm"),
        "active": data.get("actief", False),
        "start_date": data.get("startdatum"),
        "sbi_code": data.get("sbiCode"),
        "verified": False,
        "reason": None,
    }

    if not result["active"]:
        result["reason"] = "Business is no longer registered at the KVK"
        return result

    if not result["legal_form"]:
        result["reason"] = "Legal form unknown"
        return result

    result["verified"] = True
    return result


# Utilisation
freelancer = verify_freelancer("12345678")

if freelancer["verified"]:
    print(f"✓ {freelancer['name']} ({freelancer['legal_form']}) - active registration confirmed")
else:
    print(f"✗ Verification failed: {freelancer['reason']}")

Filtrer par forme juridique

Toutes les formes juridiques ne conviennent pas également au travail en freelance. Une entreprise individuelle (Eenmanszaak) ou une société à responsabilité limitée (BV) sont les plus courantes. Une société en nom collectif (VOF) implique plusieurs associés, ce qui peut appeler une vigilance accrue sur la question de savoir qui effectue réellement le travail.

ACCEPTED_LEGAL_FORMS = {
    "Eenmanszaak",
    "Besloten Vennootschap",
    "BV",
}

def is_valid_freelancer_form(freelancer: dict) -> bool:
    return freelancer["legal_form"] in ACCEPTED_LEGAL_FORMS

Adaptez cet ensemble à votre propre politique. Certaines entreprises acceptent aussi les VOF ; d’autres préfèrent travailler exclusivement avec des entreprises individuelles ou des BV.

Intégration dans votre parcours d’onboarding fournisseurs

Le contrôle s’intègre naturellement à un processus d’onboarding de nouveau fournisseur :

def onboard_freelancer(name: str, kvk_number: str, email: str) -> str:
    """
    Onboard a freelancer after KVK verification.
    Returns: 'approved', 'manual_review', or 'rejected'.
    """
    try:
        data = verify_freelancer(kvk_number)
    except requests.HTTPError as e:
        if e.response.status_code == 404:
            return "rejected"  # Le numéro KVK n'existe pas
        raise

    if not data["verified"]:
        log_manual_review(kvk_number, name, data["reason"])
        return "manual_review"

    if not is_valid_freelancer_form(data):
        log_manual_review(kvk_number, name, f"Unusual legal form: {data['legal_form']}")
        return "manual_review"

    save_freelancer({
        "name": data["name"],
        "kvk_number": kvk_number,
        "legal_form": data["legal_form"],
        "email": email,
        "verified_at": datetime.utcnow().isoformat(),
    })

    return "approved"

Recertification périodique

Un contrôle unique à l’onboarding ne suffit pas. Une entreprise peut se faire radier à tout moment. Intégrez une recertification périodique à votre système pour tous les freelances actifs :

from datetime import datetime, timedelta
import time

def recertify_all_freelancers(freelancers: list, max_age_days: int = 90) -> list:
    """
    Check all freelancers to see if their KVK registration is still active.
    Returns a list of freelancers with issues.
    """
    cutoff = datetime.utcnow() - timedelta(days=max_age_days)
    flagged = []

    for f in freelancers:
        last_verified = datetime.fromisoformat(f.get("verified_at", "2000-01-01"))
        if last_verified > cutoff:
            continue  # Contrôlé récemment, on passe

        result = verify_freelancer(f["kvk_number"])
        time.sleep(0.2)  # Respecter les limites de débit

        if not result["verified"]:
            flagged.append({
                "name": f["name"],
                "kvk_number": f["kvk_number"],
                "issue": result["reason"],
            })

    return flagged

# À exécuter chaque jour ou chaque semaine
problems = recertify_all_freelancers(get_all_active_freelancers())
for p in problems:
    send_alert(f"Freelancer {p['name']} ({p['kvk_number']}): {p['issue']}")

Wet DBA : ce que les employeurs doivent savoir

L’administration fiscale néerlandaise applique la Wet DBA depuis 2025. Une immatriculation KVK ne garantit pas une qualification correcte de la relation de travail, mais c’est un point de départ obligatoire. Combinez le contrôle KVK avec :

• Un contrat type approuvé (modelovereenkomst)
• Des preuves d’une réelle indépendance dans le travail (pas de lieu de travail fixe, pas de lien de subordination)
• Le fait que le freelance travaille pour plusieurs clients

La vérification KVK via l’API KVKBase constitue la couche technique. L’appréciation juridique reste un jugement humain.

En résumé

• Vérifiez le numéro KVK de chaque nouveau freelance avant de commencer à travailler ou de payer des factures
• Contrôlez actief: true et une rechtsvorm appropriée
• Prévoyez une recertification périodique pour les prestataires existants (tous les 90 jours est un intervalle raisonnable)
• Automatisez cela dans votre pipeline d’onboarding fournisseurs

À lire aussi : Les données KVK pour l’onboarding client pour une mise en œuvre plus large de la vérification KVK dans votre processus d’accueil client, et le suivi du statut des entreprises KVK pour des alertes en temps réel lorsque les statuts d’immatriculation changent.