Skip to content

JSON naar YAML omzetter

Plak JSON en krijg direct YAML. Live conversie in je browser. K8s/Compose-klaar, 2/4 spaties inspringing, slimme aanhalingstekens. 100% privé, geen upload.

Geen tracking Draait in je browser Gratis
Opties · 2 spaties · auto · blok
Inspringing
Stijl
0 tekens
YAML Uitvoer
0 regels
Gecontroleerd op RFC 8259-naleving, YAML 1.2-specificatie-uitvoer en correcte afhandeling van het Norway-probleem — Go Tools Engineering Team · May 4, 2026

Wat is YAML en waarom omzetten vanuit JSON?

YAML (YAML Ain't Markup Language) is een door mensen leesbaar dataserialiseringsformaat dat is ontworpen voor configuratiebestanden, infrastructuur als code en overal waar een mens data schrijft die een machine zal lezen. De op inspringing gebaseerde syntaxis vereist geen accolades of haakjes, waardoor het veel leesbaarder is dan JSON voor complexe geneste structuren. Kubernetes, Helm, Ansible, Docker Compose, GitHub Actions, CircleCI en vrijwel elke cloud-native tool gebruikt YAML als primair configuratieformaat. JSON omzetten naar YAML is daardoor een van de meest voorkomende taken in DevOps en backend-ontwikkeling — je ontvangt een resourcedefinitie van een API in JSON, en je hebt een YAML-manifest nodig om te committen naar versiebeheer.

Deze tool heeft vier belangrijke onderscheidende kenmerken ten opzichte van typische online omzetters:

**1. Norway-probleem — Automatisch veilige aanhalingstekens.** De grootste valkuil bij het omzetten van JSON naar YAML is het YAML Norway-probleem. In YAML 1.1 (dat miljoenen productieparsers nog steeds gebruiken, waaronder oudere Kubernetes, PyYAML, Ansible en Ruby's Psych) worden de kale strings yes, no, on, off, y en n verwerkt als boolean true/false-waarden. Dit raakte beroemd de ISO-landcode voor Noorwegen ("NO" → false) en heeft echte productieontwrichtingen in Kubernetes-configuraties veroorzaakt. YAML 1.2 heeft dit opgelost, maar je parsers zijn mogelijk nog niet op 1.2. De standaard Auto-aanhalingstekenmodus van deze tool gebruikt de eemeli/yaml-bibliotheek met het YAML 1.1-schema, waardoor alle Norway-probleemstrings automatisch tussen aanhalingstekens worden geplaatst, wat veilige rondes garandeert via zowel YAML 1.1- als 1.2-parsers. Lees meer in ons begeleidend artikel op Het YAML Norway-probleem en JSON-YAML-verschillen.

**2. Sleutelvolgorde bewaren.** Anders dan sommige omzetters die sleutels alfabetisch sorteren, bewaart deze tool de oorspronkelijke invoegvolgorde van sleutels uit je JSON — wat overeenkomt met het gedrag van JSON.parse() in alle moderne JavaScript-engines. Dit is belangrijk voor Kubernetes-manifests (waarbij apiVersion en kind conventioneel als eerste worden verwacht), OpenAPI-specificaties (waarbij info voor paths staat) en elke configuratie waarbij de volgorde van velden betekenisvol is voor leesbaarheid of diffs.

**3. Voorbehoud grote getallen.** JSON-getallen groter dan 2^53 - 1 (9007199254740991) kunnen niet exact worden weergegeven in JavaScript's IEEE 754 dubbele precisie float. Wanneer JSON.parse() een groot geheel getal leest, zoals een Kubernetes resourceVersion-veld (dat een 64-bit geheel getal is op de server), wordt het stilzwijgend afgekapt. Dit is een fundamentele browserbeperking die alle browsergebaseerde JSON-tools beïnvloedt, inclusief deze. De veilige oplossing is ervoor te zorgen dat grote gehele getallen als strings in je JSON worden opgeslagen voordat je omzet. Deze tool documenteert dit gedrag eerlijk in de veelgemaakte fout 'Precisieverlies bij grote gehele getallen' hieronder.

**4. 100% browsergebaseerde privacy.** Je JSON-data — die vaak API-sleutels, databasegegevens, interne serviceconfiguraties en productiegeheimen bevat — verlaat je browser nooit. Er worden geen gegevens naar een server verzonden. Je kunt dit verifiëren in het tabblad Netwerk van je browser. Dit is de enige veilige manier om gevoelige configuratiedata in een online tool te verwerken. Zie onze begeleidende tool voor de omgekeerde richting op YAML naar JSON omzetter, en onze JSON-formatter als je JSON wilt valideren en mooi afdrukken voordat je omzet.

De door mensen leesbare aard van YAML gaat gepaard met een afweging: het heeft meer parsing-randgevallen dan JSON. Naast het Norway-probleem heeft YAML octale getalleneigenaardigheden (0777 wordt 511 in YAML 1.1), meerdere regels syntaxis voor strings (| voor letterlijk, > voor gevouwen), anker- en aliasreferenties (&anker en *alias), en ondersteuning voor meerdere documenten (--- scheidingsteken). JSON heeft geen van deze complexiteiten — het is een strikt, minimaal formaat met slechts zes gegevenstypen. Voor machine-to-machine gegevensuitwisseling is JSON vrijwel altijd de betere keuze. Voor door mensen bewerkte configuratiebestanden waarbij leesbaarheid en commentaar belangrijk zijn, wint YAML. Deze omzetter geeft je het beste van beide werelden: gebruik JSON programmatisch, zet om naar YAML voor je infrastructuur.

// Convert JSON to YAML in Node.js using the eemeli/yaml library
import { Document } from 'yaml';

const data = JSON.parse('{"apiVersion":"apps/v1","kind":"Deployment"}');

// version: '1.1' ensures Norway-problem strings (yes/no/on/off/y/n)
// are automatically quoted in the output for YAML 1.1 parser safety
const doc = new Document(data, { version: '1.1' });

const yamlString = doc.toString({
  indent: 2,
  lineWidth: 0,         // disable line wrapping
  defaultStringType: 'PLAIN',   // Auto mode: only quote when needed
});

console.log(yamlString);
// apiVersion: apps/v1
// kind: Deployment

Kernfuncties

Live conversie

YAML-uitvoer wordt direct bijgewerkt terwijl je JSON typt of plakt — geen Omzetten-knop nodig. Grote invoer (>200 KB) schakelt automatisch over naar handmatige modus om de browser responsief te houden.

2 of 4 spaties inspringing

Schakel tussen 2 spaties (standaard voor Kubernetes, Docker Compose en GitHub Actions) en 4 spaties (Ansible-conventie) inspringing. YAML-tabs zijn verboden — deze tool gebruikt altijd spaties.

Automatisch veilige aanhalingstekens (Norway-veilig)

De standaard Auto-modus gebruikt het YAML 1.1-schema om automatisch aanhalingstekens te plaatsen rond strings zoals "no", "yes", "on", "off", "y" en "n" die door YAML 1.1-parsers als booleans zouden worden gelezen, wat productie-misconfiguraties voorkomt.

Blok- en flowstijlen

Blokstijl geeft ingesprongen, door mensen leesbare YAML die ideaal is voor manifests en configuratiebestanden. Flowstijl geeft compacte, inline YAML vergelijkbaar met JSON — handig voor documentatiefragmenten of tools die minimale uitvoer verkiezen.

100% browsergebaseerde privacy

Alle conversie draait lokaal in je browser via JavaScript. Je JSON-data — inclusief API-sleutels, gegevens en productieconfiguraties — wordt nooit naar een server verzonden, nooit gelogd en nooit opgeslagen.

Werkt met K8s, Compose en Terraform-bestanden

Geoptimaliseerd voor realistische DevOps-gebruiksscenario's: Kubernetes-manifests, Docker Compose-stacks, Helm chart values, GitHub Actions-workflows, OpenAPI-specificaties en Terraform JSON-planuitvoer — met voorbeelden voor elk.

Voorbeelden

Kubernetes Deployment

{"apiVersion":"apps/v1","kind":"Deployment","metadata":{"name":"my-app","namespace":"production","labels":{"app":"my-app","version":"1.0.0"}},"spec":{"replicas":3,"selector":{"matchLabels":{"app":"my-app"}},"template":{"metadata":{"labels":{"app":"my-app"}},"spec":{"containers":[{"name":"my-app","image":"my-app:1.0.0","ports":[{"containerPort":8080}],"resources":{"requests":{"memory":"64Mi","cpu":"250m"},"limits":{"memory":"128Mi","cpu":"500m"}}}]}}}}

Zet een Kubernetes Deployment-manifest van JSON API-responsformaat om naar YAML, zodat je het kunt toepassen met kubectl apply -f

Docker Compose

{"version":"3.9","services":{"web":{"image":"nginx:1.25-alpine","ports":["80:80","443:443"],"environment":{"NGINX_HOST":"example.com","NGINX_PORT":"80"},"depends_on":["db"],"restart":"unless-stopped"},"db":{"image":"postgres:16-alpine","environment":{"POSTGRES_DB":"mydb","POSTGRES_USER":"admin","POSTGRES_PASSWORD":"secret"},"volumes":["pgdata:/var/lib/postgresql/data"]}},"volumes":{"pgdata":{}}}

Zet een Docker Compose-servicedefinitie van JSON om naar het YAML-formaat dat docker compose up vereist

GitHub Actions-workflow

{"name":"CI","on":{"push":{"branches":["main"]},"pull_request":{"branches":["main"]}},"jobs":{"build":{"runs-on":"ubuntu-latest","steps":[{"uses":"actions/checkout@v4"},{"name":"Set up Node.js","uses":"actions/setup-node@v4","with":{"node-version":"20","cache":"pnpm"}},{"name":"Install dependencies","run":"pnpm install --frozen-lockfile"},{"name":"Run tests","run":"pnpm test"}]}}}

Zet een GitHub Actions CI-workflowdefinitie van JSON om naar YAML, zodat je het kunt committen naar .github/workflows/

OpenAPI-specificatie

{"openapi":"3.0.3","info":{"title":"User API","version":"1.0.0","description":"Manage application users"},"paths":{"/users":{"get":{"summary":"List users","operationId":"listUsers","parameters":[{"name":"limit","in":"query","schema":{"type":"integer","default":20}}],"responses":{"200":{"description":"Success","content":{"application/json":{"schema":{"type":"array","items":{"$ref":"#/components/schemas/User"}}}}}}}},"/users/{id}":{"get":{"summary":"Get user","operationId":"getUser","parameters":[{"name":"id","in":"path","required":true,"schema":{"type":"string"}}],"responses":{"200":{"description":"Success"}}}}},"components":{"schemas":{"User":{"type":"object","properties":{"id":{"type":"string"},"name":{"type":"string"},"email":{"type":"string","format":"email"}}}}}}

Zet een OpenAPI 3.0-specificatie van JSON om naar YAML — het voorkeursformaat voor Swagger UI, Redoc en de meeste API-tooling

package.json

{"name":"my-app","version":"1.0.0","description":"A sample Node.js application","private":true,"scripts":{"dev":"vite","build":"tsc && vite build","preview":"vite preview","test":"vitest","lint":"eslint . --ext .ts,.tsx"},"dependencies":{"react":"^18.3.0","react-dom":"^18.3.0"},"devDependencies":{"typescript":"^5.4.0","vite":"^5.2.0","vitest":"^1.5.0","eslint":"^8.57.0","@types/react":"^18.3.0"},"engines":{"node":">=20.0.0","pnpm":">=9.0.0"}}

Zet een typisch Node.js package.json om naar YAML — handig voor het migreren van projectconfiguratie naar tools die YAML verkiezen

Terraform JSON-plan

{"format_version":"1.0","terraform_version":"1.7.4","variables":{"region":{"value":"us-east-1"}},"planned_values":{"root_module":{"resources":[{"address":"aws_s3_bucket.main","mode":"managed","type":"aws_s3_bucket","name":"main","values":{"bucket":"my-app-assets","force_destroy":false,"tags":{"Environment":"production","ManagedBy":"terraform"}}}]}},"resource_changes":[{"address":"aws_s3_bucket.main","mode":"managed","type":"aws_s3_bucket","name":"main","change":{"actions":["create"],"before":null,"after":{"bucket":"my-app-assets","force_destroy":false}}}]}

Zet een Terraform JSON-planuitvoer om naar YAML voor menselijke review, GitOps-auditsporen en CI/CD-pipelines — een functie die de meeste omzetters missen

Zo gebruik je het

  1. 1

    Plak je JSON

    Voer je JSON-data in of plak deze in het invoerveld hierboven. Je kunt ook op 'Voorbeeld laden' klikken om een voorbeeld te proberen, zoals een Kubernetes Deployment, Docker Compose-bestand of Terraform-plan.

  2. 2

    Bekijk de live YAML-uitvoer

    YAML verschijnt direct in het uitvoerpaneel. Pas Opties aan (inspringing 2/4, aanhalingstekens Auto/Dubbel/Enkel, stijl Blok/Flow) om te voldoen aan de vereisten van je doeltool.

  3. 3

    Kopieer of download

    Klik op Kopiëren om de YAML naar je klembord te halen, of op Downloaden om het op te slaan als .yaml-bestand dat klaar is voor kubectl apply, docker compose up of een andere tool.

Veelgemaakte fouten bij conversie

Afsluitende komma's

JSON staat geen komma toe na het laatste element in een object of array. Dit komt vaak voor bij het kopiëren uit JavaScript-code, die afsluitende komma's wel toestaat. Verwijder de laatste komma voordat je omzet.

✗ Fout 
{"name": "Alice", "role": "admin",}
✓ Correct 
{"name": "Alice", "role": "admin"}

Enkele aanhalingstekens

JSON vereist dubbele aanhalingstekens voor alle stringwaarden en objectsleutels. Enkele aanhalingstekens zijn geldig in JavaScript en Python, maar zijn een syntaxisfout in JSON.

✗ Fout 
{'name': 'Alice', 'active': true}
✓ Correct 
{"name": "Alice", "active": true}

Sleutels zonder aanhalingstekens

Alle JSON-objectsleutels moeten tussen dubbele aanhalingstekens staan. Sleutels zonder aanhalingstekens zijn geldig in JavaScript-objectliterals maar veroorzaken een verwerkingsfout in strikte JSON.

✗ Fout 
{name: "Alice", role: "admin"}
✓ Correct 
{"name": "Alice", "role": "admin"}

Commentaar niet toegestaan

Standaard JSON ondersteunt geen commentaar van welke soort dan ook — niet //, /* */ of #. Als je commentaar in configuratie nodig hebt, gebruik dan YAML (dat # commentaar ondersteunt) of JSONC (JSON met commentaar, gebruikt door VS Code). Verwijder alle commentaar voordat je data als JSON gebruikt.

✗ Fout 
{"port": 8080 // HTTP port}
✓ Correct 
{"port": 8080}

YAML Norway-probleem (automatisch afgehandeld in Auto-modus)

In YAML 1.1-parsers (gebruikt door Kubernetes, Ansible, PyYAML, Ruby Psych) worden kale strings yes, no, on, off, y en n verwerkt als boolean true/false in plaats van strings. De Auto-modus van deze tool plaatst automatisch aanhalingstekens rond deze waarden in de YAML-uitvoer om veilige rondes via elke YAML 1.1- of 1.2-parser te garanderen. Als je Dubbel of Enkel aanhalingstekenmodus selecteert, worden alle strings expliciet aangehaald, wat het probleem ook voorkomt — maar de Auto-modus geeft de meest natuurlijk uitziende uitvoer.

✗ Fout 
# JSON input: {"country": "no", "enabled": "yes"}
# YAML without quoting (dangerous):
country: no
enabled: yes
# YAML 1.1 parser reads: country=false, enabled=true
✓ Correct 
# YAML with Auto quoting (safe):
country: 'no'
enabled: 'yes'
# YAML 1.1 parser reads: country="no", enabled="yes"

Precisieverlies bij grote gehele getallen

JavaScript kan gehele getallen alleen exact weergeven tot 2^53 - 1 (9007199254740991). JSON-gehele getallen groter dan dit — zoals Kubernetes resourceVersion-velden (die int64 zijn op de server) — worden stilzwijgend afgerond door JSON.parse(). Dit afgekapte getal verschijnt vervolgens in de YAML-uitvoer. Dit is een fundamentele browserbeperking die alle browsergebaseerde JSON-tools beïnvloedt. De veilige oplossing is het opslaan van grote gehele getallen als strings in je JSON voordat je omzet.

✗ Fout 
// JSON input (resourceVersion is int64 on K8s server)
{"resourceVersion": 9007199254740993}
// JavaScript reads it as: 9007199254740992 (precision lost)
// YAML output will contain the wrong number
✓ Correct 
// Store large integers as strings to preserve precision
{"resourceVersion": "9007199254740993"}
// YAML output: resourceVersion: '9007199254740993' (exact)

Veelvoorkomende gebruiksscenario's

Kubernetes-manifests
Zet JSON API-responses van kubectl get -o json of de Kubernetes-API om naar YAML-manifests voor GitOps-workflows, Kustomize-overlays en kubectl apply -f-implementaties.
Docker Compose-bestanden
Transformeer docker inspect JSON-uitvoer of programmatisch gegenereerde serviceconfiguraties naar docker-compose.yaml-bestanden die compatibel zijn met docker compose up en Docker Stack-implementaties.
Helm chart values
Zet JSON-configuratie-exports om naar YAML values-bestanden voor Helm chart-implementaties, wat versiebeheerde infrastructuurconfiguratie mogelijk maakt met een heldere YAML-syntaxis.
GitHub Actions-workflows
Bouw GitHub Actions-workflowdefinities programmatisch in JSON en zet ze om naar het .github/workflows/*.yaml-formaat dat de GitHub Actions-runner vereist.
OpenAPI-specificaties
Zet OpenAPI/Swagger-specificaties van het JSON-formaat dat door veel frameworks (FastAPI, SpringDoc) wordt geretourneerd om naar het YAML-formaat dat de voorkeur heeft van Swagger UI, Redoc en API-gateway-tooling.
Configuratiemigratie
Migreer applicatieconfiguratie opgeslagen in JSON (appsettings.json, config.json) naar YAML-formaat voor tools die YAML vereisen of verkiezen, en voeg de mogelijkheid toe om commentaar te gebruiken voor documentatie.

Technische details

RFC 8259-conforme JSON-verwerking
JSON-invoer wordt verwerkt via de ingebouwde JSON.parse() van de browser, die volledig voldoet aan RFC 8259. Dit geeft nauwkeurige syntaxisfoutmeldingen inclusief positie-informatie (beste schatting van regel- en kolomnummers) en verwerkt alle JSON-gegevenstypen: strings, getallen, booleans, null, arrays en objecten.
YAML 1.2-uitvoer via eemeli/yaml Document API met YAML 1.1-schema
YAML wordt gegenereerd via de eemeli/yaml-bibliotheek (v2.8+, CVE-veilig) via de Document API met version: '1.1'. Deze combinatie geeft YAML 1.2-conforme uitvoer terwijl YAML 1.1-aanhalingstekensregels worden toegepast — wat betekent dat Norway-probleemstrings (yes/no/on/off/y/n) automatisch worden aangehaald in de uitvoer, waardoor ze veilig zijn voor zowel YAML 1.1- als 1.2-parsers. Regelafbreking is uitgeschakeld (lineWidth: 0) om lange strings intact te houden.
100% browsergebaseerd — geen upload, geen server
Alle verwerking vindt volledig plaats in de JavaScript-engine van je browser. Er worden geen gegevens via het netwerk verzonden. Invoer groter dan 200 KB schakelt automatisch over van live-modus naar handmatige modus (waarbij een expliciete klik op Omzetten nodig is) om de browser responsief te houden en blokkering van de hoofdthread tijdens zware serialisatie te voorkomen.

Aanbevolen aanpak

Gebruik altijd de Auto-aanhalingstekenmodus voor DevOps-configuraties
Bij het omzetten van JSON voor gebruik in Kubernetes, Helm, Ansible, Docker Compose of GitHub Actions, gebruik altijd de standaard Auto (Norway-veilige) aanhalingstekenmodus. YAML 1.1-parsers in deze tools zullen kale strings yes, no, on, off, y en n stilzwijgend als booleans verwerken — de Auto-modus voorkomt dit transparant.
Gebruik 2 spaties inspringing voor cloud-native tools
Kubernetes, Docker Compose, GitHub Actions en Helm gebruiken allemaal conventioneel 2 spaties inspringing. 4 spaties inspringing in deze bestanden gebruiken is geldige YAML maar creëert inconsistentie met communityvoorbeelden, automatisch gegenereerde configuraties en de bestaande manifests van je team.
Sla grote gehele getallen op als strings voordat je omzet
Kubernetes resourceVersion, uid en andere int64-velden van de API-server kunnen het veilige gehele getalbereik van JavaScript (2^53 - 1) overschrijden. Als je exacte numerieke precisie nodig hebt, sla deze waarden op als JSON-strings voordat je omzet. Dit is vooral belangrijk voor kubectl get -o json-uitvoer die door de server gegenereerde velden bevat.
Valideer JSON eerst
Als je JSON-bron handgeschreven is of afkomstig is van een systeem dat soms ongeldige uitvoer geeft (afsluitende komma's, sleutels zonder aanhalingstekens, commentaar), valideer het dan eerst met een JSON-formatter. Gebruik onze JSON-formatter om syntaxisfouten te vinden en te herstellen, en zet dan de schone JSON om naar YAML.
Gebruik blokstijl voor bestanden die naar versiebeheer gaan
Blokstijl YAML geeft schone, door mensen leesbare diffs in Git omdat elk veld op zijn eigen regel staat. Flowstijl (compact, inline) maakt diffs moeilijker te lezen en te reviewen. Bewaar flowstijl voor het insluiten van korte YAML-fragmenten in documentatie of voor tools die compacte uitvoer vereisen.

Veelgestelde vragen

Hoe zet ik JSON online om naar YAML?
Plak je JSON in het invoerveld hierboven. De tool zet het direct in je browser om naar YAML — geen klikken nodig. Je kunt de inspringing (2 of 4 spaties), de aanhalingstekenstijl (Auto, Dubbel of Enkel) en de uitvoerstijl (Blok of Flow) aanpassen via het Opties-paneel. Zodra de YAML in het uitvoergebied verschijnt, klik je op Kopiëren om het naar je klembord te halen, of op Downloaden om het op te slaan als .yaml-bestand. Alles draait lokaal in je browser — je data verlaat je apparaat nooit.
Wat is het YAML Norway-probleem en hoe gaat deze tool ermee om?
Het YAML Norway-probleem verwijst naar een eigenaardigheid in de YAML 1.1-specificatie waarbij kale strings zoals "no", "yes", "on", "off", "y" en "n" worden verwerkt als boolean-waarden (false/true) in plaats van strings. Dit veroorzaakte een beroemd echt probleem: de ISO-landcode voor Noorwegen ("NO") werd in Ansible-playbooks en Kubernetes-configuraties verkeerdelijk gelezen als de boolean false. In YAML 1.2 is dit opgelost, maar miljoenen productieparsers (oudere Kubernetes-versies, PyYAML, Ansible, Ruby's Psych) gebruiken nog steeds YAML 1.1. De standaard Auto-aanhalingstekenmodus van deze tool zet automatisch aanhalingstekens rond alle Norway-probleemstrings, zodat ze veilig werken met zowel YAML 1.1- als 1.2-parsers. Wanneer Norway-probleemstrings in je invoer worden gedetecteerd, toont een waarschuwingsbanner precies welke waarden automatisch zijn aangehaald.
Waarom is het Norway-probleem belangrijk voor Kubernetes en DevOps?
Kubernetes YAML-manifests, Helm chart values, Ansible-playbooks en GitHub Actions-workflows worden allemaal verwerkt door tools die van oudsher YAML 1.1 gebruiken. Als een configuratiesleutel de waarde "no" heeft (bijvoorbeeld een landcode, een ingeschakelde vlag als string of een aangepast boolean-achtig veld), zal een YAML 1.1-parser het stilzwijgend omzetten naar de boolean false. Dit kan servicemisconfiguraties veroorzaken die extreem moeilijk te debuggen zijn, omdat de YAML er als tekst correct uitziet maar zich anders gedraagt wanneer hij wordt verwerkt. Gebruik altijd de Auto-aanhalingstekenmodus bij het omzetten van JSON voor gebruik in Kubernetes of een andere DevOps-toolchain om veilige rondes te garanderen.
Moet ik 2 of 4 spaties inspringing gebruiken voor YAML?
Gebruik 2 spaties inspringing voor Kubernetes-manifests, Helm values, Docker Compose-bestanden en GitHub Actions-workflows — deze tools zijn ontworpen rondom 2-spatie YAML en dit is de conventie van de community. Gebruik 4 spaties inspringing voor Ansible-playbooks (die een 4-spatieconventie volgen) en wanneer je team of organisatie een stijlgids heeft die dit verplicht stelt. YAML verbiedt tabs volledig — alle inspringing moet spaties zijn. Deze tool heeft standaard 2 spaties, wat de juiste keuze is voor de overgrote meerderheid van cloud-native gebruiksscenario's.
Hoe gebruik ik deze tool om een Kubernetes-manifest te maken?
Als je een Kubernetes-resourcedefinitie in JSON hebt (van kubectl get deployment my-app -o json, een API-respons of een Terraform-resourceblok), plak deze dan in het invoerveld. Selecteer 2 spaties inspringing (standaard) en Auto-aanhalingstekens (standaard, wat het Norway-probleem afhandelt). De YAML-uitvoer is direct klaar voor kubectl apply -f. Je kunt ook op Downloaden klikken om het bestand op te slaan met een .yaml-extensie en het direct te pipen via kubectl apply -f -. Het K8s Deployment-voorbeeld hierboven toont een volledig deployment-manifest dat je kunt laden en aanpassen.
Hoe zet ik een Docker Compose JSON om naar YAML?
Plak je Docker Compose JSON in het invoerveld. Gebruik 2 spaties inspringing (Docker Compose-conventie) en Blok-stijl. De YAML-uitvoer is compatibel met docker compose up, docker compose config en Docker Stack. Een veelvoorkomend scenario is het exporteren van de configuratie van een draaiende stack met docker inspect en deze vervolgens omzetten naar een compose.yaml-bestand. Het Docker Compose-voorbeeld hierboven bevat servicedefinities met poorten, omgevingsvariabelen, volumes en depends_on.
Kunnen JSON-getallen groter dan 2^53 precisie verliezen bij het omzetten naar YAML?
Ja. Dit is een fundamentele JavaScript-beperking: het IEEE 754 dubbele precisie float dat JavaScript's Number-type gebruikt, kan gehele getallen alleen exact vertegenwoordigen tot 2^53 - 1 (9007199254740991). Elk geheel getal daarboven — zoals Kubernetes resourceVersion-velden (die int64 zijn op de server) — wordt stilzwijgend afgerond wanneer het door JSON.parse() wordt verwerkt. Zo wordt de waarde 9007199254740993 in JavaScript 9007199254740992, en dit afgekapte getal verschijnt in je YAML-uitvoer. Dit heeft gevolgen voor alle browsergebaseerde JSON-tools, niet alleen deze. De veilige oplossing is het opslaan van grote gehele getallen als strings in je JSON ("resourceVersion": "9007199254740993") — ze verschijnen dan als YAML-strings zonder precisieverlies.
Bewaart de omzetter de oorspronkelijke sleutelvolgorde uit mijn JSON?
Ja. De eemeli/yaml-bibliotheek die door deze tool wordt gebruikt, bewaart de invoegvolgorde, wat overeenkomt met het gedrag van JSON.parse() in alle moderne JavaScript-engines (V8, SpiderMonkey, JavaScriptCore). Sleutels verschijnen in de YAML-uitvoer in dezelfde volgorde als in de JSON-invoer. Dit is belangrijk voor Kubernetes-manifests en OpenAPI-specificaties waar de veldvolgorde vaak betekenisvol is voor leesbaarheid en diffs.
Wanneer moet ik JSON versus YAML gebruiken?
Gebruik JSON wanneer: je API's en webservices bouwt (JSON is het universele uitwisselingsformaat), wanneer verwerkingssnelheid door machines belangrijk is, wanneer je strikte type-veiligheid nodig hebt, of wanneer de ontvanger een JavaScript/TypeScript-applicatie is. Gebruik YAML wanneer: je configuratiebestanden schrijft bedoeld voor menselijke bewerking (Kubernetes-manifests, CI/CD-pipelines, Ansible-playbooks, Helm values), wanneer je commentaar in je configuratie wilt, of wanneer leesbaarheid belangrijker is dan striktheid. Een handige vuistregel: als een machine het eerst schrijft of leest, gebruik JSON; als een mens het schrijft en een machine het leest, gebruik YAML.
Hoe kan ik JSON op de commandoregel omzetten naar YAML?
De populairste aanpak is het combineren van yq en jq. Installeer yq (de versie van Mike Farah, niet de Python-versie): brew install yq op macOS of wget https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 -O /usr/local/bin/yq voor Linux. Voer dan uit: cat input.json | yq -P om mooi af te drukken als YAML. Als alternatief: yq -o yaml input.json of cat input.json | python3 -c "import sys, json, yaml; yaml.dump(json.load(sys.stdin), sys.stdout, default_flow_style=False)". Specifiek voor Kubernetes: kubectl get deployment my-app -o yaml converteert direct via de cluster-API.
Hoe zet ik JSON om naar YAML in Python, Node.js of Go?
In Python: import json, yaml; yaml.dump(json.load(open('input.json')), open('output.yaml', 'w'), default_flow_style=False) met PyYAML, of ruamel.yaml voor round-trip-getrouwheid. In Node.js: import { Document } from 'yaml'; const doc = new Document(JSON.parse(input), { version: '1.1' }); const result = doc.toString({ indent: 2, lineWidth: 0 }) — dit is dezelfde bibliotheek en aanpak die door deze tool wordt gebruikt. In Go: import gopkg.in/yaml.v3; json.Unmarshal(jsonBytes, &data); yaml.Marshal(data) — let op dat Go YAML v3 standaard YAML 1.1 gebruikt, dus Norway-probleemstrings worden automatisch aangehaald.
Worden mijn JSON-gegevens naar een server verzonden bij gebruik van deze tool?
Nee. Alle conversie vindt volledig plaats in je browser via JavaScript. Je JSON-data wordt nooit via het netwerk verzonden, nooit opgeslagen op een server, en nooit gelogd of geanalyseerd. Dit maakt de tool veilig voor gebruik met API-sleutels, databasegegevens, interne configuratiebestanden, productie-Kubernetes-manifests en alle andere gevoelige data. De tool gebruikt geen cookies voor je invoerdata en geen externe analyses die je plakactie zouden vastleggen. Je kunt dit verifiëren door het tabblad Netwerk van je browser te openen — je ziet nul verzoeken bij het plakken van JSON.
Is er een bestandsgroottelimiet voor JSON-invoer?
Er is geen harde bestandsgroottelimiet, maar grote invoer (meer dan 200 KB) schakelt automatisch over van live-conversie naar handmatige modus. In handmatige modus verschijnt een Omzetten-knop en vindt conversie alleen plaats wanneer je erop klikt — dit voorkomt dat de hoofdthread van de browser 200-500 ms blokkeert bij elke toetsaanslag. Voor zeer grote JSON-bestanden (meerdere megabytes) kun je beter commandoregeltools zoals yq of jq gebruiken voor betere prestaties. De tool verwerkt efficiënt typische realistische payloads zoals volledige Kubernetes-naamruimte-exports, grote OpenAPI-specificaties en Docker Compose-bestanden met meerdere services.

Gerelateerde tools

Alle tools bekijken →

Base64 decoderen en encoderen online

Encodering en formattering

Base64 decoderen en encoderen direct in je browser. Realtime conversie met volledige UTF-8- en emoji-ondersteuning. 100% privé — geen account nodig.

Online JSON-formatter & validator

Encodering en formattering

Formatteer en valideer JSON direct in je browser. Gratis online tool met syntaxvalidatie, foutdetectie, minificeren en kopiëren met één klik. 100% privé.

URL decoderen en encoderen online

Encodering en formattering

Decodeer of encodeer URL's in realtime met ingebouwde URL-parser. Twee modi: encodeURI en encodeURIComponent. 100% privé, geen data naar servers.

YAML naar JSON omzetter

Encodering en formattering

Plak YAML en krijg direct JSON. Live conversie in je browser. K8s-manifests, OpenAPI-specificaties en Helm values ondersteund. 100% privé, geen upload.

Talstelsel omrekenen — online converter

Omrekentools

Reken je getal direct om tussen binair, hex, decimaal, octaal en elk talstelsel (2-36). Gratis en privé — alles draait in je browser.

Afbeelding comprimeren — online tool

Omrekentools

Comprimeer JPEG, PNG & WebP tot 80% kleiner — in je browser, zonder uploaden. Batch 20 afbeeldingen, stel kwaliteit in, vergelijk voor & na. Gratis & privé.