Bedrijfsstatus monitoren met de KVK API: faillissementen en wijzigingen opvangen

Een klant die vorige week nog netjes betaalde, kan volgende week failliet zijn. Een leverancier die al jaren op hetzelfde adres zat, is inmiddels uitgeschreven. Voor B2B-bedrijven zijn dit geen hypothetische scenario’s, maar realistische risico’s die financieel flink kunnen schaden.

Met de KVKBase API kun je dit soort wijzigingen automatisch opvangen, zonder dagelijks handmatig het Handelsregister te raadplegen. In dit artikel leggen we uit hoe je bedrijfsstatus monitort, welke signalen er toe doen en hoe je dat praktisch inricht.

Welke statuswijzigingen zijn relevant?

Het KVK-register bevat niet alleen statische bedrijfsgegevens, maar ook actuele statusinformatie. De wijzigingen die het meest impact hebben op je bedrijfsvoering zijn:

• Faillietverklaring: het bedrijf is failliet verklaard door de rechtbank
• Surseance van betaling: het bedrijf heeft uitstel van betaling aangevraagd
• Uitschrijving: het bedrijf is officieel opgeheven en uit het register verwijderd
• Adreswijziging: het vestigingsadres is gewijzigd, relevant voor post en facturering
• Naamswijziging: het bedrijf opereert voortaan onder een andere naam
• Wijziging rechtsvorm: van eenmanszaak naar BV, of omgekeerd
• Wijziging bestuurders: andere personen zijn nu tekenbevoegd

Niet elk van deze wijzigingen is even urgent. Een adreswijziging is administratief van aard; een faillietverklaring vereist directe actie vanuit credit management of accounts receivable.

Waarom handmatige controle niet werkt

De neiging bij veel bedrijven is om debiteuren of leveranciers ad hoc te controleren, pas wanneer er al iets mis is gegaan. Een openstaande factuur die maar niet betaald wordt, een aanmaning die retour komt op een oud adres.

Op dat moment is de schade al geleden. Preventief monitoren is een stuk effectiever: je weet het vóórdat je een factuur stuurt, vóórdat je een grote levering doet of vóórdat je een contract tekent.

Handmatig het Handelsregister controleren voor een lijst van honderden klanten is geen optie. Een geautomatiseerde monitoring via de API wel.

Bedrijfsstatus opvragen via de KVKBase API

De KVKBase API geeft je het actief veld en aanvullende statusinformatie terug bij elk bedrijf. Hier is een eenvoudige implementatie in Python:

import os
import requests

API_KEY = os.getenv("KVKBASE_API_KEY")
BASE_URL = "https://api.kvkbase.nl/api/v1"

def check_company_status(kvk_number: str) -> dict:
    response = requests.get(
        f"{BASE_URL}/kvk/{kvk_number}",
        headers={"x-api-key": API_KEY}
    )
    response.raise_for_status()
    data = response.json()

    return {
        "kvk_number": kvk_number,
        "name": data.get("naam"),
        "active": data.get("actief", True),
        "legal_form": data.get("rechtsvorm"),
        "address": data.get("adres", {}),
    }

# Controleer een specifiek bedrijf
status = check_company_status("12345678")
if not status["active"]:
    print(f"WAARSCHUWING: {status['name']} is niet meer actief!")

Bulk monitoring: je volledige klantenlijst doorlopen

In de praktijk wil je niet één bedrijf controleren, maar je volledige klantenlijst. Dat doe je het efficiëntst met een periodieke batch job, gecombineerd met een alert-mechanisme.

import time
import smtplib
from email.message import EmailMessage
from typing import List

def monitor_portfolio(kvk_numbers: List[str]) -> List[dict]:
    """Controleer een lijst KVK-nummers en geef waarschuwingen terug."""
    alerts = []

    for kvk in kvk_numbers:
        try:
            status = check_company_status(kvk)
            if not status["active"]:
                alerts.append({
                    "kvk_number": kvk,
                    "company": status["name"],
                    "reason": "Bedrijf niet meer actief in KVK"
                })
            time.sleep(0.2)  # Respecteer rate limits
        except Exception as e:
            print(f"Fout bij ophalen {kvk}: {e}")

    return alerts

def send_alert_email(alerts: List[dict], recipient: str):
    if not alerts:
        return

    msg = EmailMessage()
    msg["Subject"] = f"KVK Monitor: {len(alerts)} bedrijf/bedrijven vereist aandacht"
    msg["From"] = "monitor@jouwbedrijf.nl"
    msg["To"] = recipient

    body = "De volgende bedrijven zijn niet meer actief:\n\n"
    for alert in alerts:
        body += f"- {alert['company']} (KVK: {alert['kvk_number']})\n"
        body += f"  Reden: {alert['reason']}\n\n"

    msg.set_content(body)

    with smtplib.SMTP("localhost") as smtp:
        smtp.send_message(msg)

Adreswijzigingen detecteren

Adreswijzigingen vereisen een andere aanpak. Je hebt een referentiepunt nodig: het adres dat je in eigen systeem hebt opgeslagen. De API-response vergelijk je dan met je eigen database.

import json

def detect_address_changes(kvk_number: str, stored_address: dict) -> dict | None:
    """Vergelijk huidig KVK-adres met opgeslagen adres."""
    current = check_company_status(kvk_number)
    api_address = current.get("address", {})

    fields_to_check = ["straat", "huisnummer", "postcode", "plaats"]
    changes = {}

    for field in fields_to_check:
        stored_val = stored_address.get(field, "").lower().strip()
        api_val = str(api_address.get(field, "")).lower().strip()
        if stored_val != api_val and api_val:
            changes[field] = {
                "oud": stored_address.get(field),
                "nieuw": api_address.get(field)
            }

    if changes:
        return {
            "kvk_number": kvk_number,
            "company": current["name"],
            "changes": changes
        }
    return None

Frequentie en strategie

Hoe vaak je monitort, hangt af van je risicoprofiel:

Segment	Aanbevolen frequentie	Reden
Grote debiteuren (>10k open)	Dagelijks	Hoog financieel risico
Reguliere klanten	Wekelijks	Balans tussen risico en API-gebruik
Incidentele klanten	Maandelijks	Laag volume, laag risico
Leveranciers	Maandelijks	Continuïteitsrisico

Voor de meeste bedrijven is een wekelijkse nachtelijke batch job per segment een goede balans. Koppel dit aan je webhook-configuratie als je naast periodieke checks ook real-time updates wilt ontvangen.

Integratie met je CRM of ERP

De monitoring is pas echt krachtig als je hem koppelt aan je bestaande systemen. Stel je voor:

• Een klant wordt failliet verklaard, waarna automatisch een taak wordt aangemaakt voor de credit manager in je CRM
• Een leverancier schrijft zich uit, waarna de inkoopmodule een waarschuwing toont bij de volgende bestelling
• Een debiteur wijzigt van adres, waarna alle openstaande facturen automatisch het nieuwe adres krijgen

Deze integraties zijn haalbaar met de KVKBase API als databron en een eenvoudige middleware-laag die events vertaalt naar acties in je ERP of CRM-systeem.

Starten met monitoren

Wil je bedrijfsstatus-monitoring inrichten voor je eigen portfolio? Begin met deze stappen:

1. Exporteer je KVK-nummers uit je CRM of boekhoudpakket
2. Haal een API-key op via het KVKBase dashboard
3. Stel een eerste batch check in via een Python script of een cron job
4. Definieer je alertdrempels - wat triggert een melding, en naar wie?
5. Koppel aan je workflow - is een Slack-bericht voldoende, of moet er direct een taak worden aangemaakt?

Monitoring is geen eenmalig project maar een doorlopend proces. Bedrijven veranderen continu, en de meeste wijzigingen worden pas een probleem als je ze te laat opmerkt. Met geautomatiseerde KVK-monitoring heb je altijd een actueel beeld van je klantenportfolio, zonder dat iemand er dagelijks handmatig doorheen hoeft.

Lees ook: Nieuw ingeschreven bedrijven als B2B leads voor de andere kant van de medaille, namelijk nieuwe kansen spotten via het Handelsregister.