# JSON Schema Strict Validator MCP

> JSON Schema Strict Validator MCP ensures your JSON data structures are perfectly aligned with your definitions. It provides a deterministic, zero-tolerance approach to validation, catching even the smallest type mismatches or extra properties that shouldn't be there. This is essential for preventing breaking changes in automated pipelines and maintaining high-integrityுscriping scripts and configuration files.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_sKAvGA9c25B3JDMRML1RCTYWBZLrC4d0YNzpeThq/mcp
- **Tags:** json, schema, validation, testing, devops

## Tools

### validate_json
Parses a JSON instance and checks it against a specific schema for any type errors or missing fields.

### verify_integrity
Checks that environment variables or key-value strings match the expected types you've defined.

### evaluate_compatibility
Evaluates if a new JSON Schema is compatible with an old one

## Prompt Examples

**Prompt:** 
```
Validate this JSON object against the schema: {"name": "John", "age": 30} with schema {"type": "object", "properties": {"name": {"type": "string"}}, "required": ["name"]}
```

**Response:** 
```
{"isValid": true, "validationErrors": []}
```

**Prompt:** 
```
Check if this JSON is valid: {"id": 123, "extra": true} against schema {"type": "object", "properties": {"id": {"type": "number"}}}
```

**Response:** 
```
{"isValid": false, "validationErrors": [{"path": "/extra", "errorType": "UNAUTHORIZED_PROPERTY", "expected": "none", "actual": "true"}]}
```

**Prompt:** 
```
Is the string 'VERSION=1.0' valid for the key VERSION with type string?
```

**Response:** 
```
{"isHealthy": true, "structuralIssues": []}
```

## Capabilities

### Catch type mismatches
Automatically detects when a string, number, or boolean is used where it should be an object or array.

### Block unauthorized extra properties
Enforces strict property enforcement to prevent unexpected data bloatat at the root or nested levels.

### undefined
undefined

### undefined
undefined

## Use Cases

### Preventing broken CI/CD pipelines
A DevOps engineer needs to verify that a new configuration file is valid against the project's master schema. They ask their agent, and the MCP validates it instantly.

### Checking API response structures
        A backend developer is debuggingging an engineering lead's change to an API endpoint. They use the MCP to check if the new JSON response matches the schema definition.

### undefined
An engineer needs to check if a environment variable string is correctly formatted for a deployment. The agent uses verify_integrity to ensure it's valid.

### Verifying schema migration-related changes
A developer is updating a schema version from Draft-07 to 2020-12. They use the MCP to check if the migration will break any existing data structures.

## Benefits

- Stop silent failures by using validate_json to catch type mismatches before they code reaches production.
- Keep your configuration files clean and predictable with strict property enforcement via the validation engine.
- Prevent breaking changes in your API contracts by running evaluate_compatibility between schema versions.
- Ensure environment variable stability by using verify_integrity to check types against expected constraints.
- Maintain a single source of truth for all JSON data structures across your entire development lifecycle.

## How It Works

The bottom line is you get an error-free, schema-compliant codebase or configuration setup.

1. Connect your preferred AI client to the JSON Schema Strict Validator MCP via Vinkius.
2. Provide a JSON instance and a target schema for validation.
3. Receive immediate, deterministic results showing exactly where any violations occur.

## Frequently Asked Questions

**What does 'strict mode' mean in this validator?**
Strict mode means that if a schema does not explicitly define `additionalProperties`, the validator treats it as `false`. Any property found in the JSON instance that is not declared in the schema will trigger an error.

**Can I use this to check for breaking changes in my API?**
Yes, by using the `evaluate_compatibility` tool, you can compare an old schema against a new one to identify removed required fields or properties that might break your integration.

**How do I validate environment variables?**
You can use the `verify_integrity` tool. Pass a string of key-value pairs (like `PORT=8080`) and an array of constraints to ensure each key matches its expected type.