Claude Code veilig instellen: permissions, sandbox en MCP (2026)

Claude Code kan veilig in een repository werken als je alleen noodzakelijke rechten verleent, secrets afschermt en elke wijziging controleert. Begin met handmatige goedkeuring of plan mode, combineer permissions met sandboxing en behandel elke MCP-server als een externe integratie die je eerst moet beoordelen.

In het kort

Start Claude Code in de kleinste relevante projectmap.
Gebruik plan mode voor onderzoek en de handmatige standaardmodus voor gecontroleerde wijzigingen.
Leg harde grenzen vast met deny-regels, want die gaan voor ask en allow.
Schakel de sandbox in voor besturingssysteemniveau-isolatie van Bash-processen.
Bescherm credentialbestanden en geheime omgevingsvariabelen expliciet.
Voeg alleen vertrouwde MCP-servers toe en zet nooit geheime waarden rechtstreeks in .mcp.json.
Controleer de volledige diff en alle externe effecten voordat je commit, pusht of deployt.

Lees eerst Claude Code gebruiken als de basiscommando's nog nieuw zijn. Voor privacyregels die voor meerdere AI-tools gelden, sluit AI veilig gebruiken hierop aan.

Begrijp eerst het dreigingsmodel

Claude Code kan bestanden lezen, bestanden bewerken, shellcommando's uitvoeren en via gekoppelde tools externe systemen benaderen. Daardoor zijn er vier verschillende risicogebieden:

Onbedoelde wijzigingen: een te brede opdracht raakt meer bestanden dan bedoeld.
Gevoelige gegevens: een tool of commando leest een .env, SSH-sleutel of cloudcredential.
Prompt injection: tekst uit een repository, webpagina of tool probeert de oorspronkelijke opdracht te veranderen.
Externe effecten: een commando of MCP-tool pusht code, wijzigt data, verstuurt een bericht of start een deployment.

Geen enkele instelling dekt al deze gebieden alleen. Permissions bepalen welke tools en paden Claude mag gebruiken. De sandbox beperkt Bash-processen op besturingssysteemniveau. Je Git-werkwijze maakt wijzigingen herstelbaar. Menselijke review blijft nodig voor betekenis, architectuur en bedrijfsrisico.

Stappenplan: Claude Code veilig configureren

Stap 1: werk vanuit een controleerbare repository

Start niet vanuit je home-directory of een bovenliggende map met meerdere projecten. Ga naar de kleinste map die Claude nodig heeft:

cd /pad/naar/je-project
git status
claude

Controleer vóór de sessie:

of bestaand werk is opgeslagen of duidelijk zichtbaar is in git status;
of secrets buiten de repository staan en door .gitignore worden uitgesloten;
of je op een aparte branch of werkboom werkt;
welke test-, lint- en buildcommando's als verificatie gelden;
welke acties buiten scope zijn, zoals pushen, deployen of productiegegevens wijzigen.

Een instructie als "niet pushen" helpt de agent begrijpen wat je wilt. Een expliciete deny-regel is sterker, omdat die het gereedschap zelf begrenst.

Stap 2: kies een passende permission mode

Claude Code heeft meerdere permission modes. Voor veilig beginnen zijn deze twee het belangrijkst:

Plan mode: Claude onderzoekt met alleen-lezen mogelijkheden en maakt een plan zonder bronbestanden aan te passen.
Handmatige standaardmodus: Claude vraagt goedkeuring voor acties die meer rechten nodig hebben.

Open het rechtenoverzicht met:

/permissions

Geef niet uit gemak brede, permanente toestemming voor alle Bash-commando's. Sta liever een klein, herkenbaar commando toe, zoals een specifiek testscript. Controleer de opgeslagen regel voordat je "niet opnieuw vragen" kiest.

De officiële permissionregels worden beoordeeld in de volgorde deny, ask, allow. Een passende deny blijft dus van kracht als een andere configuratielaag een bredere toestemming bevat.

Stap 3: leg harde grenzen vast

Projectinstellingen die het team mag delen staan in .claude/settings.json. Een voorzichtig startpunt kan er zo uitzien:

{
  "permissions": {
    "allow": [
      "Bash(npm test)",
      "Bash(npm run lint)",
      "Bash(npm run build)"
    ],
    "ask": [
      "Bash(git commit *)"
    ],
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Bash(git push *)",
      "Bash(npm publish *)",
      "Bash(vercel *)"
    ]
  }
}

Pas dit voorbeeld aan je echte toolchain aan. Een regel voor Bash(npm test) staat alleen dat exacte commando toe. Een spatie vóór * in Bash(git push *) is belangrijk, omdat de wildcard dan als vervolg op het commando wordt behandeld.

Let op een cruciale beperking: Read- en Edit-regels gelden voor ingebouwde bestandstools. Een Bash-proces kan andere routes gebruiken om een bestand te lezen. Gebruik daarom daarnaast de sandbox als je ook subprocessen op besturingssysteemniveau wilt begrenzen.

Stap 4: schakel sandboxing in

Open het sandboxmenu met:

/sandbox

Op macOS gebruikt Claude Code daarvoor Seatbelt. Op Linux en WSL2 gebruikt het bubblewrap; daarvoor kunnen aanvullende systeempakketten nodig zijn. Native WSL1 wordt niet ondersteund voor deze sandbox.

Een strengere projectconfiguratie kan beginnen met:

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": false,
    "failIfUnavailable": true,
    "allowUnsandboxedCommands": false,
    "filesystem": {
      "denyRead": ["~/"],
      "allowRead": ["."]
    },
    "network": {
      "allowedDomains": [
        "registry.npmjs.org"
      ]
    }
  }
}

Hier blokkeert denyRead eerst de home-directory, waarna allowRead de projectmap opnieuw opent. Dit voorbeeld hoort in projectinstellingen te staan, zodat . naar de projectroot verwijst.

Twee instellingen verdienen extra aandacht:

failIfUnavailable: true voorkomt dat Claude Code bij een ontbrekende sandbox alleen waarschuwt en daarna zonder sandbox doorgaat.
allowUnsandboxedCommands: false schakelt de ontsnappingsroute uit waarbij een niet-compatibel commando na toestemming buiten de sandbox kan worden herhaald.

Controleer welke netwerkdomeinen je build werkelijk nodig heeft. Een brede wildcard kan het nut van netwerkisolatie verkleinen. De sandboxproxy filtert standaard op hostnaam en inspecteert versleutelde inhoud niet automatisch.

Wil je voorkomen dat Claude Code bij een nieuw netwerkdomein alsnog om toestemming vraagt, gebruik dan vanaf versie 2.1.219 sandbox.network.strictAllowlist. Met true worden sandboxed commando's naar hosts buiten de effectieve allowlist direct geweigerd. Die allowlist bestaat uit allowedDomains en domeinen die met toegestane WebFetch(domain:...)-regels zijn vastgelegd.

Zet deze sleutel niet in .claude/settings.json of .claude/settings.local.json: Claude Code negeert hem daar. Plaats hem in je gebruikersinstellingen (~/.claude/settings.json), in beheerde instellingen of geef de configuratie voor de sessie mee via --settings:

{
  "sandbox": {
    "enabled": true,
    "network": {
      "allowedDomains": ["registry.npmjs.org"],
      "strictAllowlist": true
    }
  }
}

strictAllowlist begrenst alleen sandboxed commando's. De ingebouwde WebFetch-tool draait in het Claude Code-proces en blijft zijn eigen permissionregels volgen.

Stap 5: bescherm credentials apart

Volgens de actuele sandboxdocumentatie mogen Bash-processen standaard veel bestanden lezen, waaronder mogelijk credentials in je home-directory. Voeg daarom gerichte credentialregels toe. Dit onderdeel vereist Claude Code v2.1.187 of nieuwer:

{
  "sandbox": {
    "enabled": true,
    "credentials": {
      "files": [
        { "path": "~/.aws/credentials", "mode": "deny" },
        { "path": "~/.ssh", "mode": "deny" }
      ],
      "envVars": [
        { "name": "GITHUB_TOKEN", "mode": "deny" },
        { "name": "NPM_TOKEN", "mode": "deny" }
      ]
    }
  }
}

Maak daarnaast de omgeving zelf klein:

gebruik repositoryspecifieke of kortlevende tokens;
geef een token alleen scopes die de taak nodig heeft;
mount geen volledige ~/.ssh- of cloudconfiguratiemap in een container;
laat productiecredentials buiten een ontwikkelsessie;
roteer een credential direct als die toch in output, Git of een gedeeld log terechtkomt.

Stap 6: beoordeel MCP-servers als externe software

MCP koppelt Claude Code aan aanvullende databronnen en acties. Dat kan handig zijn voor GitHub, databases of interne documentatie, maar een server is niet automatisch door Anthropic beheerd of gecontroleerd.

Gebruik de juiste scope:

local: alleen voor jou binnen het huidige project, geschikt voor experimenten;
project: gedeeld via .mcp.json en zichtbaar in versiebeheer;
user: beschikbaar in al je projecten.

Een project-scoped server vraagt om vertrouwen voordat Claude Code hem gebruikt. Controleer vóór goedkeuring:

wie de server onderhoudt;
welke tools en gegevens hij ontsluit;
of acties alleen lezen of ook schrijven;
naar welke host data wordt verstuurd;
hoe authenticatie en logging zijn geregeld;
of je de server met permissions verder kunt beperken.

Zet API-sleutels niet letterlijk in .mcp.json. Gebruik omgevingsvariabelen:

{
  "mcpServers": {
    "interne-api": {
      "type": "http",
      "url": "${INTERNE_API_URL}/mcp",
      "headers": {
        "Authorization": "Bearer ${INTERNE_API_TOKEN}"
      }
    }
  }
}

De configuratie kan zo gedeeld worden zonder het token zelf te committen. Voeg alleen geen standaardwaarde met een echt geheim toe.

Stap 7: isoleer werk met een groter risico

Voor onbekende repositories, installatie van veel dependencies of autonome runs is een dev container of VM verstandiger dan je gewone ontwikkelomgeving. Anthropic biedt een referentie voor development containers met een niet-rootgebruiker en optionele beperking van uitgaand netwerkverkeer.

Ook een container is geen magische grens. Alles wat je erin mount of als environment variable meegeeft kan binnen die omgeving bereikbaar zijn. Mount daarom alleen het project en de strikt benodigde credentials.

Gebruik --dangerously-skip-permissions niet op je gewone computer. De officiële documentatie beperkt een eventueel gebruik tot zorgvuldig geïsoleerde omgevingen en waarschuwt dat ook daar gemounte bestanden, beschikbare secrets en toegestane netwerkbestemmingen risico blijven lopen.

Veiligheidschecklist voor elke opdracht

Voor de sessie

Ik werk in de juiste repository en op een herstelbare branch of werkboom.
git status laat zien welk bestaand werk ik moet behouden.
De scope en verboden acties staan expliciet in de opdracht.
Secrets staan buiten Git en zijn niet breder beschikbaar dan nodig.
Permissions blokkeren push, publicatie en andere acties buiten scope.
De sandbox is actief en faalt dicht als dat voor deze taak nodig is.
MCP-servers en plugins zijn gecontroleerd en minimaal bevoegd.

Tijdens de sessie

Ik lees de uitleg bij ieder onverwacht permissionverzoek.
Ik geef brede rechten niet permanent uit gemak.
Ik voer geen onbetrouwbare web- of repositorytekst direct als instructie uit.
Ik controleer onverwachte netwerkverzoeken en nieuwe dependencies.
Ik stop de sessie als Claude buiten scope wil werken.

Voor commit of oplevering

Ik bekijk de volledige diff, niet alleen de samenvatting.
Tests, lint, typecheck en build zijn aantoonbaar uitgevoerd.
Een secretsscan en relevante beveiligingscontrole zijn gedaan.
Er zijn geen onverwachte binaire bestanden, logs of configuraties toegevoegd.
Geen externe actie is uitgevoerd zonder dat die bij de opdracht hoorde.
Ik begrijp de beveiligingsgevolgen van de wijziging.

Lees bij persoonsgegevens en bewaartermijnen ook ChatGPT en de AVG. De leverancier verschilt, maar principes als dataminimalisatie, doelbinding en controle op externe verwerking blijven relevant.

Veelgemaakte fouten

Alleen op de bevestigingsvraag vertrouwen

Veel toestemming geven zorgt voor minder prompts, maar ook voor minder controlemomenten. Leg echte grenzen vast in deny-regels en de sandbox.

Read-regels verwarren met sandboxisolatie

Een Read(./.env)-blokkade beschermt tegen de ingebouwde Read-tool, maar niet automatisch tegen elk Bash-commando. Gebruik meerdere beveiligingslagen.

De sandbox laten terugvallen zonder het te merken

Standaard kan een ontbrekende sandbox tot een waarschuwing leiden terwijl commando's daarna zonder sandbox draaien. Gebruik failIfUnavailable wanneer isolatie een harde eis is.

Alle netwerkdomeinen toestaan

Een wildcard maakt installatie eenvoudiger, maar vergroot ook de ruimte voor data-exfiltratie. Sta alleen noodzakelijke en vertrouwde hosts toe.

Een MCP-server vertrouwen omdat hij populair is

Populariteit bewijst niet welke code vandaag draait of welke gegevens worden verwerkt. Controleer herkomst, rechten en datastroom.

Secrets in gedeelde configuratie zetten

Een werkende .mcp.json met een letterlijk token is nog steeds een datalek. Gebruik omgevingsvariabelen of een beheerde secretoplossing.

Automatische output als eindcontrole gebruiken

Claude kan tests uitvoeren en een diff samenvatten, maar kan dezelfde verkeerde aanname in implementatie en review herhalen. Beoordeel kritieke wijzigingen zelf of laat een onafhankelijke review uitvoeren.

Veelgestelde vragen

Is Claude Code veilig om in een repository te gebruiken?

Claude Code kan veilig worden ingezet als je rechten beperkt, wijzigingen controleert en gevoelige bestanden, netwerktoegang en externe tools bewust afschermt.

Welke permission mode is het veiligst om mee te beginnen?

Gebruik plan mode voor alleen onderzoek of de handmatige standaardmodus als Claude wijzigingen moet voorstellen en je acties wilt goedkeuren.

Wat beschermt de Claude Code-sandbox?

De sandbox beperkt Bash-processen op besturingssysteemniveau voor bestandstoegang en netwerkverkeer, binnen de grenzen die je zelf configureert.

Beschermt sandboxing automatisch al mijn secrets?

Nee. De standaard leesregels kunnen gevoelige bestanden nog toelaten, dus blokkeer credentialbestanden en geheime omgevingsvariabelen expliciet.

Is een MCP-server automatisch betrouwbaar?

Nee. Controleer de leverancier, gevraagde rechten, configuratie en datastromen en geef een MCP-server alleen de minimale benodigde toegang.

Moet ik --dangerously-skip-permissions gebruiken?

Gebruik deze optie niet op je gewone computer of bij een onbekende repository. Alleen een zorgvuldig geïsoleerde container of VM met beperkte secrets en netwerktoegang kan het risico verkleinen.

Wat controleer ik voordat ik wijzigingen commit?

Bekijk de volledige diff, draai tests en statische controles, zoek naar secrets en controleer expliciet of er geen onverwachte externe acties of bestanden buiten scope zijn geraakt.

Bronnen

Dit artikel is inhoudelijk gecontroleerd op 28 juli 2026 aan de hand van primaire bronnen: