What Is Kubernetes Manifest Validator?
Kubernetes Manifest Validator is a free online tool by TechnSols that checks your Kubernetes YAML against bundled JSON Schemas, in your browser. You paste a manifest, and the tool reports missing fields, wrong types, deprecated APIs, and common security mistakes before you apply anything.
A manifest can be valid YAML and still be wrong for Kubernetes: a Deployment without a selector, a Service without a port, or an Ingress on an API version the cluster removed years ago. The Kubernetes objects guide defines what each object must hold, and this validator turns those rules into checks you can run before kubectl ever sees the file.
Validation runs on Ajv, the JSON Schema validator, against compact schemas bundled with the tool for the common workload kinds. If the manifest needs editing first, the Kubernetes YAML Editor tool edits it with syntax checks and formatting.
People use it to review a manifest before a pull request, to learn why kubectl rejected a file, and to catch the :latest tag or the missing resource limits before they reach production. It suits a first Deployment, a Helm chart rendered to plain YAML, or a whole multi-document file. The report it writes is plain text, so you can paste it into the review.
How To Use Kubernetes Manifest Validator?
Here is how to validate a Kubernetes manifest online in three quick steps. Using Kubernetes Manifest Validator is simple. There is no software to install and no account to make. Paste the manifest, press Validate, and read the report. If the manifest is JSON instead of YAML, the JSON Validator tool checks that form.
Step 1: Paste The Manifest
Paste your manifest into the input box, or press Load Valid Sample to see a Deployment that passes, then Load Invalid Sample to see what a failing report looks like. The validator accepts one resource or several documents separated by — lines, and it checks each document on its own.
Step 2: Press Validate
Press Validate Manifest. The tool parses the YAML first, then runs each document through the schema for its kind, and then runs the extra rules: deprecated apiVersion values, containers using the :latest tag, missing resource requests and limits, privileged containers, and Services without ports. Each problem is listed with the field it belongs to.
Step 3: Read The Report And Fix
Read the report from the top: errors first, then warnings. Errors mean the manifest cannot apply as written, while warnings mean it can apply but should not. Fix the errors in your editor, paste the file again, and validate until the report is clean. If the YAML itself will not parse, the YAML Validator tool shows the exact syntax error first.
The whole job takes a few minutes. A file built from a form is ready to use, and the steps above are the same every time.
Why Kubernetes Manifest Validator?
kubectl errors arrive late, after the file is written, committed, and pushed, and they often point at the wrong line. A browser validator moves the check earlier, to the moment the file is still on your screen. The mistakes it catches are the common ones: a missing selector, a wrong type, a removed API, a port that does not match. If the app also runs locally first, the Docker Compose Builder tool builds the stack it ran in before Kubernetes.
The checks come from the real API definitions. The Kubernetes API reference lists every field each object accepts, and the bundled schemas are written from those definitions for the common kinds. The tool checks structure and types, not opinions, so a pass means the shape matches the API.
Errors Before The Cluster
A Deployment without spec.selector fails at apply time, and the error is easy to miss in a long file. The validator flags the missing field before the file leaves your machine, with the field name in the message. Fixing it here costs seconds, while fixing it after a failed deploy costs a whole cycle.
Deprecated APIs Get Flagged
Manifests copied from old tutorials still use extensions/v1beta1 for Deployments and networking.k8s.io/v1beta1 for Ingress, and both were removed from Kubernetes years ago. The validator flags those apiVersion values as errors, so the file is fixed before it meets a cluster that refuses it.
Security Mistakes Surface Early
Containers running as root, privileged containers, and images pinned to :latest are the three habits that cause the most production incidents. The validator warns about each one, so the review catches them. If the pipeline that applies the manifest needs a map, the Pipeline Visualizer tool draws it from the workflow file.
What Can You Do With Kubernetes Manifest Validator?
A manifest validator fits any review where a bad file costs time. These are the jobs this validator handles best.
Review A Manifest Before A Pull Request
Paste the manifest from the branch, run the check, and paste the report into the review when it is clean. A reviewer who sees a clean report can focus on the design instead of hunting for a missing field. It turns the review into a conversation about intent, not typos.
Learn Why Kubectl Rejected A File
When kubectl reports an error you do not understand, paste the same file here. The report lists each problem with its field, which usually explains the kubectl message in plain terms. Fix the listed fields, validate again, and apply the file once the report is clean.
Check A Rendered Helm Chart
Render the chart with helm template, then paste the rendered YAML here. The validator checks every document in the file, so a bad value in one template shows up before the chart is installed. The Dockerfile Generator tool writes the Dockerfile for the image the chart deploys.
Quality And Settings
The bundled schemas cover the common kinds: Deployment, Service, Pod, ConfigMap, Secret, Ingress, StatefulSet, DaemonSet, Job, CronJob, Namespace, ServiceAccount, and PersistentVolumeClaim. Each schema lists the required fields and the types the API expects, and Ajv reports every failure, not just the first. Unknown kinds are not failed for being unknown: they get the generic checks for apiVersion, kind, and metadata name, and the report says the kind has no bundled schema. If an API spec needs the same treatment, the OpenAPI Schema Validator tool validates it with the same Ajv engine.
- Parses YAML with js-yaml 4.1.0, then validates each document separately.
- Validates with Ajv 8.17.1 against bundled JSON Schemas for the common kinds.
- Flags removed API versions, such as extensions/v1beta1, as errors.
- Warns about :latest tags, missing resource limits, and privileged containers.
- Reports errors first, then warnings, each with the field it belongs to.
Two honest limits apply. The schemas are compact versions written from the API definitions, not the full Kubernetes schema bundle, so they check the fields teams get wrong most often, not every field the API accepts. And no browser check can replace the cluster: admission rules, quotas, and the live state are only visible to kubectl. Use this check first, then dry-run before you apply.
How Kubernetes Manifest Validator Works
The validator reads the pasted text and parses it with js-yaml loadAll, so multi-document files split into separate documents. Each document is matched to the bundled schema for its apiVersion and kind, and Ajv compiles that schema and validates the document, collecting every error with its field path. The extra rules then run: deprecated versions, :latest tags, missing limits, privileged flags, and missing selectors. If the repo needs an ignore file too, the Gitignore Generator tool writes one the same way.
Two limits are worth knowing. The validator checks the shape of the manifest, and it cannot check that the values are right for your cluster: only the API server knows whether the namespace exists or the image is reachable. It also never talks to a cluster, so it cannot apply the file or read the live state. Download the report, fix the file, and apply it with kubectl yourself.
Privacy
Everything you paste stays in your browser. The manifest is checked on your own computer, and nothing you enter is uploaded to a server, stored, or shared with anyone. Closing the tab clears the input, so the manifest details never leave your device.
Because no account is needed, there is no name, email, or history tied to what you check. Closing the tab ends the session, and the browser clears the input from memory. That is the same protection on every tool here: your work stays yours, and nothing about it is kept, shared, or sold.
Tips
A few habits make Kubernetes Manifest Validator work smoother, whether this is your first file or your fiftieth.
- Validate before every kubectl apply, and paste the clean report into the review.
- Replace :latest with a pinned tag, so a redeploy does not pull a surprise.
- Set resource requests and limits on every container, without exception.
- Keep the Service selector labels identical to the pod template labels.
- Delete manifests that use removed API versions instead of patching them.
When the manifest is clean, keep it in version control next to the code it deploys, so the next change updates both together. If the manifest must become JSON for another tool, the YAML to JSON tool converts it.
More Tools For The Same Job
These tools handle the same kinds of jobs: writing, checking, and converting manifests and YAML.
- Kubernetes YAML Editor: edits the manifest this validator checks.
- YAML Validator: checks any YAML file for syntax errors.
- YAML to JSON Converter: turns the manifest into JSON for tools that read JSON.
- JSON Validator: checks the JSON form of the manifest.
- Dockerfile Generator: writes the Dockerfile for the image the manifest runs.
- Docker Compose Builder: builds the local stack the app ran in before Kubernetes.
- CI/CD Pipeline Visualizer: maps the pipeline that applies this manifest.
- OpenAPI Schema Validator: validates API specs with the same Ajv engine.
- Gitignore Generator: writes the .gitignore for the repo that holds the manifests.
- README Generator: writes the README that explains how to apply the manifests.
FAQ
Common questions about validating Kubernetes manifests, answered plainly.
Is Kubernetes Manifest Validator by TechnSols Free?
Yes, Kubernetes Manifest Validator by TechnSols is completely free to use, with no account, no sign-up, and no usage limit. You can validate as many manifests as you like, and everything you paste stays in your browser, so nothing is uploaded or stored anywhere.
What Does It Actually Check?
It parses the YAML, then validates each document against a bundled JSON Schema for its kind, covering Deployments, Services, Pods, ConfigMaps, Secrets, Ingresses, StatefulSets, DaemonSets, Jobs, CronJobs, Namespaces, and ServiceAccounts. It also checks required fields, apiVersion and kind, deprecated APIs, and common security and best practice rules.
Is This The Same As A Dry Run?
No, and the difference matters. This tool checks the manifest against bundled schemas in your browser, with no cluster involved. kubectl dry-run asks the live API server, which also checks admission rules and the real cluster state. Use this tool first to catch the cheap mistakes, then dry-run before you apply.
Which Kubernetes Versions Do The Schemas Match?
The bundled schemas follow the stable APIs used by current Kubernetes: apps/v1 for workloads, v1 for core objects, batch/v1 for Jobs and CronJobs, and networking.k8s.io/v1 for Ingress. Removed APIs such as extensions/v1beta1 Deployments are flagged as deprecated, because clusters no longer accept them.
Can It Check My Secrets Too?
It can check the structure of a Secret, such as the apiVersion, kind, name, and data keys, but it cannot tell whether the values are right or safe. Never paste a real production secret into any online tool if you can avoid it. Check the shape with a placeholder value, and keep real secrets in your cluster secret store.
Paste the manifest, press Validate, and fix what the report lists. A manifest that passes here is a manifest that stands a chance at the cluster, and that is the whole point of checking it first.