Dutch Business Registration: What Developers Need to Know

As a developer working with Dutch company data, you quickly encounter terms like KVK number, branch number, SBI code, and legal form. It can seem overwhelming, but the system is more logical than it appears at first glance.

In this article we explain the Dutch trade register system from a developer perspective: what data is available, what it means, and how to use it effectively in your application.

What is the KVK?

The Kamer van Koophandel (KVK), or Chamber of Commerce, manages the Handelsregister (Trade Register): the central database of all businesses and legal entities in the Netherlands. Every entrepreneur and every company in the Netherlands is required to register here.

The Trade Register contains information about:

• The name and address of the company
• The legal form (BV, NV, sole proprietorship, etc.)
• The activities of the company (SBI codes)
• The directors and authorized representatives
• The branch locations

This data is largely public and can be looked up and used in applications.

The KVK number

The KVK number (also called the dossier number) is the primary identifier of a business or legal entity in the Trade Register.

Technical specifications:

• Length: exactly 8 digits
• Type: numeric, but always store as a string (due to leading zeros)
• Uniqueness: unique per legal entity
• Lifetime: assigned at registration and never changes
• Examples: 12345678, 01234567

// Validation
const isValidKvk = (nr) => /^\d{8}$/.test(nr);

// Database storage
// SQL: kvk_number CHAR(8) NOT NULL
// MongoDB: kvkNumber: { type: String, match: /^\d{8}$/ }

The branch number (vestigingsnummer)

In addition to the KVK number, each company has one or more branch numbers. A branch (vestiging) is a physical location where the company conducts business.

Technical specifications:

• Length: exactly 12 digits
• Relationship: one company (1 KVK number) can have multiple branches (multiple branch numbers)
• Example: 000012345678

The relationship looks like this:

Company (KVK: 12345678)
  |
  +-- Head office (Branch: 000012345678)
  +-- Amsterdam office (Branch: 000012345679)
  +-- Rotterdam office (Branch: 000012345680)

In most applications you work with the KVK number. The branch number is relevant when you need to identify specific locations, for example in logistics or location-based services.

Legal forms: the types of companies

The Netherlands has various legal forms. Each legal form has different legal characteristics that may be relevant to your application.

Legal forms with legal personality

These are independent legal entities, separate from their owners:

BV (Besloten Vennootschap — Private Limited Company)

• Most common legal form for medium-sized businesses
• Shareholders are not personally liable
• Minimum share capital: EUR 0.01
• Recognizable by “B.V.” after the name

NV (Naamloze Vennootschap — Public Limited Company)

• For large, often publicly listed companies
• Shares are freely transferable
• Minimum share capital: EUR 45,000
• Recognizable by “N.V.” after the name

Stichting (Foundation)

• No members or shareholders
• Cannot distribute profits
• Used for non-profit purposes, but also for holding structures

Vereniging (Association)

• Has members
• Two variants: with and without full legal capacity
• Think of sports clubs, industry associations

Legal forms without legal personality

With these legal forms, there is no separation between the business and the owner:

Eenmanszaak (Sole Proprietorship)

• One owner, who is fully personally liable
• No minimum capital
• The simplest legal form
• Note: for sole proprietorships, the business name may contain a personal name (GDPR-relevant)

VOF (Vennootschap Onder Firma — General Partnership)

• Two or more partners
• All partners are jointly and severally liable
• Common among collaborating professionals

Maatschap (Professional Partnership)

• Similar to VOF, but each partner is only liable for their own share
• Common among doctors, lawyers, accountants

CV (Commanditaire Vennootschap — Limited Partnership)

• Combination of general partners (liable) and silent partners (limited liability)

Impact on your application

The legal form affects how you handle the data:

function getCompanyContext(legalForm) {
  switch (legalForm) {
    case 'Eenmanszaak':
      return {
        hasPersonalData: true,    // Name may be a personal name
        addressMayBeHome: true,   // Address may be residential
        gdprSensitive: true       // Extra caution required
      };
    case 'BV':
    case 'NV':
      return {
        hasPersonalData: false,
        addressMayBeHome: false,
        gdprSensitive: false
      };
    case 'VOF':
    case 'Maatschap':
      return {
        hasPersonalData: true,    // Partners are identifiable
        addressMayBeHome: true,   // May be a residential address
        gdprSensitive: true
      };
    default:
      return {
        hasPersonalData: false,
        addressMayBeHome: false,
        gdprSensitive: false
      };
  }
}

SBI codes: business activities

SBI stands for Standaard Bedrijfsindeling (Standard Business Classification). It is a classification system that indicates which activities a company performs. Every company in the Trade Register has one or more SBI codes.

Structure

SBI codes are hierarchically organized:

Section:     J - Information and communication
  Division:  62 - Information technology
    Group:   620 - Information technology
      Class: 6201 - Software development and production
             6202 - IT consultancy
             6203 - Computer facilities management

The codes are 4 or 5 digits long. A company can have multiple SBI codes if it performs multiple activities.

Use in your application

SBI codes are useful for:

• Market segmentation: filter customers by industry
• Risk assessment: certain industries have a higher risk profile
• Compliance: some activities require permits
• Statistics: analyze your customer base by sector

// Find all IT companies in your customer base
const itCompanies = companies.filter(c =>
  c.sbiCodes.some(sbi => sbi.code.startsWith('62'))
);

// Categorize by main sector
function getSector(sbiCode) {
  const division = parseInt(sbiCode.substring(0, 2));

  if (division >= 1 && division <= 3) return 'Agriculture';
  if (division >= 10 && division <= 33) return 'Manufacturing';
  if (division >= 41 && division <= 43) return 'Construction';
  if (division >= 45 && division <= 47) return 'Trade';
  if (division >= 58 && division <= 63) return 'Information and communication';
  if (division >= 64 && division <= 66) return 'Financial services';
  if (division >= 69 && division <= 75) return 'Specialist business services';

  return 'Other';
}

Other relevant identification numbers

Besides the KVK number and branch number, you will encounter other numbers in practice:

VAT number (omzetbelastingnummer)

• Format: NL + 9 digits + B + 2 digits
• Example: NL123456789B01
• Issued by the tax authority (Belastingdienst), not by the KVK
• Not always available through the KVK API

RSIN (Legal Entities and Partnerships Information Number)

• 9 digits
• Identifies a legal entity for government systems
• Used for the Personal Records Database, among others

BSN (Citizen Service Number)

• 9 digits
• Personal identification number for natural persons
• Never available through public APIs
• Only relevant for sole proprietorships, and then only for the owner

Using the data effectively

Database design

A solid database schema for Dutch company data:

CREATE TABLE companies (
  id UUID PRIMARY KEY,
  kvk_number CHAR(8) UNIQUE NOT NULL,
  trade_name VARCHAR(255) NOT NULL,
  legal_form VARCHAR(100),
  is_active BOOLEAN DEFAULT true,
  vat_number VARCHAR(14),
  created_at TIMESTAMPTZ DEFAULT NOW(),
  updated_at TIMESTAMPTZ DEFAULT NOW(),
  verified_at TIMESTAMPTZ
);

CREATE TABLE company_addresses (
  id UUID PRIMARY KEY,
  company_id UUID REFERENCES companies(id),
  vestiging_number CHAR(12),
  address_type VARCHAR(20), -- 'visiting' or 'postal'
  street VARCHAR(255),
  house_number VARCHAR(10),
  postal_code CHAR(6),
  city VARCHAR(100),
  country CHAR(2) DEFAULT 'NL'
);

CREATE TABLE company_sbi_codes (
  company_id UUID REFERENCES companies(id),
  sbi_code VARCHAR(5),
  description VARCHAR(255),
  is_primary BOOLEAN DEFAULT false,
  PRIMARY KEY (company_id, sbi_code)
);

Search functionality

When building a search function for companies, consider multiple search fields:

async function searchCompanies(query) {
  // Is it a KVK number?
  if (/^\d{8}$/.test(query)) {
    return kvkbase.lookup(query);
  }

  // Is it a VAT number?
  if (/^NL\d{9}B\d{2}$/.test(query.replace(/[\s.]/g, ''))) {
    return kvkbase.searchByVat(query);
  }

  // Is it a postal code?
  if (/^\d{4}[A-Z]{2}$/.test(query.replace(/\s/g, ''))) {
    return kvkbase.searchByPostalCode(query);
  }

  // Search by company name
  return kvkbase.search(query);
}

Conclusion

The Dutch Trade Register is a rich source of company data with a logical structure. As a developer, you deal with a limited number of core concepts:

• KVK number (8 digits): identifies the company
• Branch number (12 digits): identifies the location
• Legal form: determines the legal character
• SBI codes: describe the activities

By understanding these concepts and correctly incorporating them into your data model, you build a solid foundation for any application that works with Dutch companies.

With KVKBase you can query all of this data through a single, well-documented API — from basic lookups to extensive search functions. That saves you from navigating complex government documentation and lets you focus on what matters: building a great product.