# How to Validate the Exercises Dataset Using JSON Schema: A Complete Guide

> Validate exercises dataset records against the formal JSON Schema. Catch type mismatches, missing keys, and malformed URLs with any Draft 2020-12 compliant validator.

- Repository: [Hasan Emir Yıldırım/exercises-dataset](https://github.com/hasaneyldrm/exercises-dataset)
- Tags: how-to-guide
- Published: 2026-07-30

---

**Validate exercise records against the formal JSON Schema in [`data/exercises.schema.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.schema.json) using any Draft 2020-12 compliant validator to catch type mismatches, missing language keys, and malformed URLs before processing.**

The **hasaneyldrm/exercises-dataset** repository maintains a structured collection of fitness exercises as JSON objects. To ensure data integrity across 1,324+ records, the repository ships a formal **JSON Schema** that defines every field, required property, and constraint. Validating the exercises dataset using JSON Schema guarantees that your application receives correctly typed multilingual content, valid media URLs, and complete metadata before ingestion.

## Understanding the JSON Schema Structure

The schema file [`data/exercises.schema.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.schema.json) follows the **Draft 2020-12** specification and serves as the strict contract for every exercise object stored in [`data/exercises.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.json).

### Schema Location and Specification

- **Schema Path**: [`data/exercises.schema.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.schema.json)
- **Data File**: [`data/exercises.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.json)
- **Specification**: Draft 2020-12 (modern JSON Schema version supporting strict type checking and advanced string formats)

### Field Definitions and Constraints

The schema enforces specific data types and constraints for each exercise record:

- **`id`**: String representing a numeric identifier
- **`name`**, **`category`**, **`body_part`**, **`equipment`**, **`muscle_group`**, **`target`**, **`media_id`**, **`image`**, **`gif_url`**, **`attribution`**: String values, with media fields requiring valid URI formats
- **`instructions`**: Object containing exactly nine required language keys (`en`, `es`, `it`, `tr`, `ru`, `zh`, `hi`, `pl`, `ko`), each holding a string instruction block
- **`instruction_steps`**: Object where each language entry is an array of strings representing step-by-step instructions
- **`secondary_muscles`**: Array of strings listing secondary muscle groups
- **`created_at`**: ISO-8601 date-time string (`format: date-time`)

## Validating with Python

Use the `jsonschema` library to validate the dataset programmatically. This approach catches missing required fields and type violations for each exercise record.

```python
import json
from jsonschema import validate, ValidationError

# Load the schema

with open("data/exercises.schema.json", "r", encoding="utf-8") as f:
    schema = json.load(f)

# Load the dataset (or any custom JSON)

with open("data/exercises.json", "r", encoding="utf-8") as f:
    exercises = json.load(f)

# Validate each record

errors = []
for idx, ex in enumerate(exercises, start=1):
    try:
        validate(instance=ex, schema=schema)
    except ValidationError as e:
        errors.append(f"Exercise #{idx} ({ex.get('id')}): {e.message}")

if errors:
    print("Validation failed:")
    for err in errors:
        print(err)
else:
    print("All exercises validated successfully")

```

## Validating with Node.js

For JavaScript environments, **AJV** (Another JSON Schema Validator) provides high-performance validation with detailed error reporting.

```javascript
const Ajv = require("ajv");
const fs = require("fs");

// Load schema and data
const schema = JSON.parse(fs.readFileSync("data/exercises.schema.json", "utf-8"));
const exercises = JSON.parse(fs.readFileSync("data/exercises.json", "utf-8"));

const ajv = new Ajv({ allErrors: true });
const validate = ajv.compile(schema);

let hasError = false;
exercises.forEach((ex, i) => {
  const valid = validate(ex);
  if (!valid) {
    hasError = true;
    console.error(`Exercise #${i + 1} (id=${ex.id}) validation errors:`);
    console.error(validate.errors);
  }
});

if (!hasError) console.log("All exercises passed AJV validation");

```

## Command-Line Validation

Use **ajv-cli** for quick validation without writing custom code. This method is ideal for CI/CD pipelines or pre-commit hooks.

```bash

# Install globally (once)

npm i -g ajv-cli

# Validate the whole dataset

ajv validate -s data/exercises.schema.json -d data/exercises.json

```

## Validating with Go

For Go applications, the `github.com/santhosh-tekuri/jsonschema/v5` library compiles the schema and validates individual records against the Draft 2020-12 specification.

```go
package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"

	"github.com/santhosh-tekuri/jsonschema/v5"
)

func main() {
	// Compile the schema
	compiler := jsonschema.NewCompiler()
	if err := compiler.AddResource("schema.json", 
		// Load from file
		// (you could also embed the schema)
	); err != nil {
		log.Fatal(err)
	}
	schema, err := compiler.Compile("schema.json")
	if err != nil {
		log.Fatal(err)
	}

	// Load the dataset
	data, _ := ioutil.ReadFile("data/exercises.json")
	var exercises []interface{}
	if err := json.Unmarshal(data, &exercises); err != nil {
		log.Fatal(err)
	}

	// Validate each entry
	for i, ex := range exercises {
		if err := schema.Validate(ex); err != nil {
			fmt.Printf("Exercise #%d validation error: %v\n", i+1, err)
		}
	}
}

```

## Summary

- Locate the authoritative schema at [`data/exercises.schema.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.schema.json) (Draft 2020-12) in the **hasaneyldrm/exercises-dataset** repository
- Validate [`data/exercises.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.json) against constraints governing 12+ string fields, multilingual instruction objects, and media URIs
- Use Python's `jsonschema`, Node's `AJV`, or Go's `jsonschema/v5` libraries for programmatic validation
- Execute `ajv-cli` for rapid command-line validation during development workflows
- Catch missing language keys, malformed ISO-8601 dates, invalid URIs, and type errors before runtime

## Frequently Asked Questions

### What JSON Schema draft does the exercises dataset use?

The schema conforms to **Draft 2020-12**, as specified in the `$schema` property within [`data/exercises.schema.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.schema.json). This modern draft supports strict type checking, advanced string formats like `date-time` and `uri`, and robust validation of nested multilingual objects.

### Which fields are required for a valid exercise record?

According to the schema definition, every exercise must include `id`, `name`, `category`, `body_part`, `equipment`, `muscle_group`, `target`, `instructions` (with all nine mandatory language keys), `instruction_steps`, `media_id`, `image`, `gif_url`, `secondary_muscles`, and `created_at`. Missing any of these properties triggers a validation error.

### Can I validate a single exercise instead of the entire array?

Yes. Most validators accept individual objects. In Python, pass a single dictionary to `validate()` instead of iterating the full list. In AJV, compile the schema once and invoke the returned validation function on a single exercise object extracted from the array.

### What common errors does the schema catch during validation?

The schema validates that `instructions` contains exactly the required language keys (`en`, `es`, `it`, `tr`, `ru`, `zh`, `hi`, `pl`, `ko`), that `created_at` matches ISO-8601 format, that media URLs conform to URI syntax, and that `secondary_muscles` is strictly an array of strings rather than a single comma-separated value.