JSON::Validator - Validate data against a JSON schema


Using a schema object

JSON::Validator::Schema or any of the sub classes can be used instead of JSON::Validator.


  use JSON::Validator;
  my $jv = JSON::Validator->new;

  # Define a schema -
  # You can also load schema from disk or web
    type       => "object",
    required   => ["firstName", "lastName"],
    properties => {
      firstName => {type => "string"},
      lastName  => {type => "string"},
      age       => {type => "integer", minimum => 0, description => "Age in years"}

  # Validate your data
  my @errors = $jv->validate({firstName => "Jan Henning", lastName => "Thorsen", age => -42});

  # Do something if any errors was found
  die "@errors" if @errors;

Using joi

  # Use joi() to build the schema
  use JSON::Validator::Joi 'joi';

    firstName => joi->string->required,
    lastName  => joi->string->required,
    age       => joi->integer->min(0),

  # joi() can also validate directly
  my @errors = joi(
    {firstName => "Jan Henning", lastName => "Thorsen", age => -42},
      firstName => joi->string->required,
      lastName  => joi->string->required,
      age       => joi->integer->min(0),


JSON::Validator is a data structure validation library based around JSON Schema. This module can be used directly with a JSON schema or you can use the elegant DSL schema-builder JSON::Validator::Joi to define the schema programmatically.

Supported schema formats

JSON::Validator can load JSON schemas in multiple formats: Plain perl data structured (as shown in "SYNOPSIS"), JSON or YAML. The JSON parsing is done with Mojo::JSON, while YAML files requires YAML::PP or YAML::XS.


Here are some resources that are related to JSON schemas and validation:

Bundled specifications

This module comes with some JSON specifications bundled, so your application don't have to fetch those from the web. These specifications should be up to date, but please submit an issue if they are not.

Files referenced to an URL will automatically be cached if the first element in "cache_paths" is a writable directory. Note that the cache headers for the remote assets are not honored, so you will manually need to remove any cached file, should you need to refresh them.

To download and cache an online asset, do this:

  JSON_VALIDATOR_CACHE_PATH=/some/writable/directory perl

Here is the list of the bundled specifications:

Optional modules


The method "validate" returns a list of JSON::Validator::Error objects when the input data violates the "schema".



Proxy attribute for "cache_paths" in JSON::Validator::Store.


  my $hash_ref = $jv->formats;
  my $jv = $jv->formats(\%hash);

Holds a hash-ref, where the keys are supported JSON type "formats", and the values holds a code block which can validate a given format. A code block should return undef on success and an error string on error:

  sub { return defined $_[0] && $_[0] eq "42" ? undef : "Not the answer." };

See JSON::Validator::Formats for a list of supported formats.


  my $jv = $jv->recursive_data_protection($bool);
  my $bool = $jv->recursive_data_protection;

Recursive data protection is active by default, however it can be deactivated by assigning a false value to the "recursive_data_protection" attribute.

Recursive data protection can have a noticeable impact on memory usage when validating large data structures. If you are encountering issues with memory and you can guarantee that you do not have any loops in your data structure then deactivating the recursive data protection may help.

This attribute is EXPERIMENTAL and may change in a future release.

Disclaimer: Use at your own risk, if you have any doubt then don't use it


  $store = $jv->store;

Holds a JSON::Validator::Store object that caches the retrieved schemas. This object can be shared amongst different schema objects to prevent a schema from having to be downloaded again.


Proxy attribute for "ua" in JSON::Validator::Store.



  # These two lines does the same
  my $schema = $jv->bundle({schema => $jv->schema->data});
  my $schema = $jv->bundle;

  # Will only bundle a section of the schema
  my $schema = $jv->bundle({schema => $jv->schema->get("/properties/person/age")});

Used to create a new schema, where there are no "$ref" pointing to external resources. This means that all the "$ref" that are found, will be moved into the "definitions" key, in the returned $schema.


  my $jv       = $jv->coerce('bool,def,num,str');
  my $jv       = $jv->coerce('booleans,defaults,numbers,strings');
  my $hash_ref = $jv->coerce;

Set the given type to coerce. Before enabling coercion this module is very strict when it comes to validating types. Example: The string "1" is not the same as the number 1, unless you have "numbers" coercion enabled.

  • booleans

    Will convert what looks can be interpreted as a boolean (that is, an actual numeric 1 or 0, and the strings "true" and "false") to a JSON::PP::Boolean object. Note that "foo" is not considered a true value and will fail the validation.

  • defaults

    Will copy the default value defined in the schema, into the input structure, if the input value is non-existing.

    Note that support for "default" is currently EXPERIMENTAL, and enabling this might be changed in future versions.

  • numbers

    Will convert strings that looks like numbers, into true numbers. This works for both the "integer" and "number" types.

  • strings

    Will convert a number into a string. This works for the "string" type.


  my $sub_schema = $jv->get("/x/y");
  my $sub_schema = $jv->get(["x", "y"]);

Extract value from "schema" identified by the given JSON Pointer. Will at the same time resolve $ref if found. Example:

  $jv->schema({x => {'$ref' => '#/y'}, y => {'type' => 'string'}});
  $jv->schema->get('/x')           == {'$ref' => '#/y'}
  $jv->schema->get('/x')->{'$ref'} == '#/y'
  $jv->get('/x')                   == {type => 'string'}

The argument can also be an array-ref with the different parts of the pointer as each elements.


  $jv = JSON::Validator->new(%attributes);
  $jv = JSON::Validator->new(\%attributes);

Creates a new JSON::Validate object.


  my $jv = $jv->load_and_validate_schema($schema, \%args);

Will load and validate $schema against the OpenAPI specification. $schema can be anything "schema" in JSON::Validator accepts. The expanded specification will be stored in "schema" in JSON::Validator on success. See "schema" in JSON::Validator for the different version of $url that can be accepted.

%args can be used to further instruct the validation process:

  • schema

    Defaults to "", but can be any structured that can be used to validate $schema.


  my $jv     = $jv->schema($json_or_yaml_string);
  my $jv     = $jv->schema($url);
  my $jv     = $jv->schema(\%schema);
  my $jv     = $jv->schema(JSON::Validator::Joi->new);
  my $jv     = $jv->schema(JSON::Validator::Schema->new);
  my $schema = $jv->schema;

Used to set a schema from either a data structure or a URL.

$schema will be a JSON::Validator::Schema object when loaded, and undef by default.

The $url can take many forms, but needs to point to a text file in the JSON or YAML format.

  • file://...

    A file on disk. Note that it is required to use the "file" scheme if you want to reference absolute paths on your file system.

  • http://... or https://...

    A web resource will be fetched using the Mojo::UserAgent, stored in "ua".

  • data://Some::Module/spec.json

    Will load a given "spec.json" file from Some::Module using "data_section" in JSON::Validator::Util.

  • data:///spec.json

    A "data" URL without a module name will use the current package and search up the call/inheritance tree.

  • Any other URL

    An URL (without a recognized scheme) will be treated as a path to a file on disk. If the file could not be found on disk and the path starts with "/", then the will be loaded from the app defined in "ua". Something like this:



  my @errors = $jv->validate($data);

Validates $data against "schema". @errors will contain validation error objects, in a predictable order (specifically, alphanumerically sorted by the error objects' path) or be an empty list on success.

See "ERROR OBJECT" for details.



Copyright (C) 2014-2021, Jan Henning Thorsen

This program is free software, you can redistribute it and/or modify it under the terms of the Artistic License version 2.0.


Jan Henning Thorsen -

Daniel Böhmer -

Ed J -

Karen Etheridge -

Kevin Goess -

Martin Renvoize -