How to Validate JSON: 5 Ways to Check for Errors

I spent three hours debugging an API integration last month. The error message was cryptic: "Invalid JSON." That's it. No line number, no explanation, just "Invalid JSON."

I checked my code. I checked the API endpoint. I checked the network requests. Everything looked fine. Finally, out of desperation, I pasted the JSON response into a validator. Two seconds later, I found it: a missing comma on line 47.

Three hours. For a missing comma.

That's when I learned the value of validating JSON before you start debugging. A quick validation check would have saved me hours of frustration. Now, I validate JSON religiously, and I want to show you how to do it too.

Here are five ways to validate JSON, from quick online checks to automated validation in your code.

Why Validate JSON?

Before we dive into the methods, let's talk about why validation matters. JSON is strict. One missing comma, one extra bracket, one unclosed quote, and your entire JSON file is invalid. The problem is, these errors aren't always obvious.

Here's a perfectly valid JSON:

{
  "name": "John",
  "age": 30,
  "city": "New York"
}

And here's the same JSON with a tiny error (missing comma):

{
  "name": "John"
  "age": 30,
  "city": "New York"
}

Can you spot the difference? It's subtle, but that missing comma after "John" breaks everything. A validator would catch this instantly and tell you exactly where the problem is.

Method 1: Online JSON Validators (The Fastest Way)

For quick validation, online tools are unbeatable. They're instant, require no setup, and give you clear error messages.

I use our JSON Formatter for this all the time. Here's how it works:

1. Paste your JSON into the input box
2. Click "Validate"
3. If there's an error, you'll see exactly what's wrong and where

The validator will tell you things like:

• "Expected ',' or '}' at line 5, column 12"
• "Unterminated string at line 3"
• "Unexpected token at line 8"

This is incredibly helpful. Instead of guessing where the error is, you get precise location information.

Best for: Quick checks, one-off validation, when you need immediate feedback

Pros:

• Instant results
• No installation required
• Clear error messages with line numbers
• Works on any device with a browser

Cons:

• Requires internet connection
• You're pasting data online (though our tool runs entirely in your browser)

Method 2: Browser Console (The Built-in Way)

Every modern browser has a built-in JSON validator: the JavaScript console. Here's how to use it:

1. Open your browser's developer tools (F12 or right-click → Inspect)
2. Go to the Console tab
3. Type: JSON.parse('your json here')
4. Press Enter

If the JSON is valid, you'll see the parsed object. If it's invalid, you'll get an error message.

Example with valid JSON:

JSON.parse('{"name": "John", "age": 30}')
// Returns: {name: "John", age: 30}

Example with invalid JSON:

JSON.parse('{"name": "John" "age": 30}')
// Error: Unexpected token " in JSON at position 18

The error message tells you exactly where the problem is (position 18 in this case).

Best for: Quick validation when you're already in the browser, testing API responses

Pros:

• Already installed (it's your browser)
• Works offline
• Fast and simple

Cons:

• Error messages can be cryptic
• Requires manual typing or pasting
• Not ideal for large files

Method 3: Code Editors and IDEs (The Developer's Way)

Most code editors have built-in JSON validation. Here's how it works in popular editors:

VS Code:

• Just open a .json file
• VS Code automatically validates it
• Errors show up with red squiggly lines
• Hover over the error to see details

Sublime Text:

• Install the "JSONLint" package
• It validates automatically as you type

Atom:

• Install the "linter-jsonlint" package
• Real-time validation with inline error messages

IntelliJ/WebStorm:

• Built-in JSON validation
• Errors highlighted automatically
• Quick fixes for common issues

The advantage of editor validation is that it happens in real-time. You see errors as you type, which prevents problems before they happen.

Best for: When you're writing or editing JSON files, development work

Pros:

• Real-time validation
• Integrated into your workflow
• Can fix errors automatically in some cases

Cons:

• Requires a code editor
• Setup needed for some editors
• Not useful if you're not a developer

Method 4: Command Line Tools (The Automated Way)

If you're working with JSON files regularly, command-line tools are powerful. Here are some options:

Using Node.js:

node -e "JSON.parse(require('fs').readFileSync('file.json', 'utf8'))"

If the JSON is valid, you'll get no output (which means success). If it's invalid, you'll see an error.

Using Python:

python -m json.tool file.json

This validates and pretty-prints the JSON. If there's an error, it tells you exactly what's wrong.

Using jq (a JSON processor):

jq . file.json

This validates and formats the JSON. If it's invalid, you'll get an error message.

Best for: Automation, scripts, batch processing multiple files

Pros:

• Can be automated
• Works in scripts and CI/CD pipelines
• Fast for batch operations

Cons:

• Requires command-line knowledge
• Need to install tools
• Not as user-friendly as GUI tools

Method 5: Programmatic Validation (The Integration Way)

If you're building an application, you'll want to validate JSON programmatically. Here's how in different languages:

JavaScript/Node.js:

function validateJSON(jsonString) {
  try {
    JSON.parse(jsonString);
    return { valid: true };
  } catch (error) {
    return { 
      valid: false, 
      error: error.message,
      position: error.message.match(/\d+/)?.[0] // Extract position if available
    };
  }
}

// Usage
const result = validateJSON('{"name": "John"}');
if (!result.valid) {
  console.error('Invalid JSON:', result.error);
}

Python:

import json

def validate_json(json_string):
    try:
        json.loads(json_string)
        return {"valid": True}
    except json.JSONDecodeError as e:
        return {
            "valid": False,
            "error": str(e),
            "line": e.lineno,
            "column": e.colno
        }

# Usage
result = validate_json('{"name": "John"}')
if not result["valid"]:
    print(f"Invalid JSON: {result['error']} at line {result['line']}")

PHP:

function validateJSON($jsonString) {
    $decoded = json_decode($jsonString);
    $error = json_last_error();
    
    if ($error === JSON_ERROR_NONE) {
        return ['valid' => true];
    } else {
        return [
            'valid' => false,
            'error' => json_last_error_msg()
        ];
    }
}

Best for: Applications that receive JSON input, APIs, data processing pipelines

Pros:

• Integrated into your application
• Can provide custom error handling
• Essential for production code

Cons:

• Requires programming knowledge
• Need to implement error handling
• More complex than other methods

Common JSON Errors and How to Spot Them

After validating thousands of JSON files, I've seen the same errors over and over. Here are the most common ones:

1. Missing Commas

{
  "name": "John"
  "age": 30  // Missing comma after "John"
}

2. Trailing Commas

{
  "name": "John",
  "age": 30,  // Trailing comma (not allowed in JSON)
}

3. Unclosed Quotes

{
  "name": "John,  // Missing closing quote
  "age": 30
}

4. Unclosed Brackets

{
  "name": "John",
  "age": 30
  // Missing closing brace

5. Comments (Not Allowed)

{
  "name": "John",
  // This is a comment - not allowed in JSON
  "age": 30
}

6. Single Quotes Instead of Double

{
  'name': 'John',  // Should be double quotes
  'age': 30
}

A good validator will catch all of these and tell you exactly where they are.

Best Practices for JSON Validation

Here's what I've learned from validating JSON professionally:

1. Validate Early: Check JSON as soon as you receive it, before processing. It's easier to catch errors early.

2. Validate in Multiple Places: Validate on the client side (before sending), on the server side (when receiving), and in your database layer (before storing).

3. Use Specific Error Messages: When validation fails, provide helpful error messages. "Invalid JSON" isn't helpful. "Missing comma at line 5, column 12" is.

4. Log Validation Errors: Keep track of validation failures. They can reveal patterns and help you fix systemic issues.

5. Validate Schema, Not Just Syntax: Syntax validation (is it valid JSON?) is different from schema validation (does it match the expected structure?). Consider both.

6. Automate Validation: Don't rely on manual checks. Use automated validation in your development workflow, CI/CD pipeline, and production code.

Real-World Validation Scenarios

Here are some situations where validation saved me:

API Integration: A client's API was returning invalid JSON intermittently. We added validation on our end and could immediately identify when the problem was on their side, not ours.

Data Migration: During a database migration, we validated all JSON fields before importing. We caught hundreds of invalid entries that would have caused problems later.

User Input: A form was accepting JSON input from users. We validated it on the frontend (for immediate feedback) and backend (for security). This prevented malformed data from entering our system.

Configuration Files: We validate all JSON configuration files on application startup. If there's an error, the app fails fast with a clear error message instead of crashing mysteriously later.

Real-World Use Cases

JSON validation isn't just theoretical—it's essential in production environments. Here are scenarios where validation saved projects:

Microservices Communication

In a microservices architecture, services exchange JSON data constantly. One service with invalid JSON can cascade failures across your entire system. Implementing validation at service boundaries catches issues before they propagate.

User-Generated Content

When users upload JSON configuration files or data imports, validation prevents malformed data from corrupting your database. E-commerce platforms, CMS systems, and data analytics tools all rely on robust JSON validation.

Third-Party API Integration

External APIs sometimes return unexpected or malformed JSON. Validating responses before processing prevents your application from crashing when a third-party service has issues.

CI/CD Pipelines

Validating configuration files (package.json, tsconfig.json, deployment configs) in your CI/CD pipeline catches errors before deployment. This prevents production outages caused by configuration mistakes.

For more on working with JSON in different contexts, see our guides on JSON payloads in APIs and working with nested JSON structures.

Common Validation Mistakes

Here are pitfalls developers encounter when validating JSON:

1. Only Validating Syntax, Not Schema

Syntax validation checks if JSON is well-formed, but doesn't verify if it contains the expected fields and types. Use schema validation (JSON Schema) to ensure data structure matches expectations. Learn more about JSON Schema validation.

2. Trusting Client-Side Validation Alone

Never rely solely on frontend validation. Always validate on the server side as well. Malicious users can bypass client-side checks, but server-side validation is mandatory for security.

3. Poor Error Messages

Generic errors like "Invalid JSON" don't help users fix problems. Provide specific error messages with line numbers and descriptions of what's wrong.

4. Not Logging Validation Failures

Track validation failures in production. Patterns in failures can reveal issues with your API documentation, client implementations, or data sources.

5. Over-Validating in Development

While validation is crucial in production, overly strict validation during development can slow down iteration. Balance validation strictness with development velocity.

For more on avoiding JSON issues, check out our article on common JSON errors and how to fix invalid JSON errors.

Best Practices for JSON Validation

After implementing validation in dozens of production systems, here are my recommendations:

1. Validate at System Boundaries: Always validate JSON when it enters or leaves your system—API endpoints, file uploads, external service calls.

2. Use Schema Validation: Define JSON schemas for your data structures. This provides documentation and automated validation.

3. Fail Fast: Validate JSON as early as possible in your processing pipeline. Don't wait until you're deep in business logic to discover invalid data.

4. Provide Helpful Error Messages: Include the line number, column, and a clear description of what's wrong. This dramatically reduces debugging time.

5. Test with Invalid Data: In your test suite, include test cases with invalid JSON to ensure your error handling works correctly.

6. Monitor Validation Failures: Track validation failure rates in production. Sudden increases might indicate issues with client implementations or API changes.

For more JSON best practices, see our guides on JSON formatting and parsing JSON in JavaScript.

Frequently Asked Questions

What's the difference between syntax validation and schema validation?

Syntax validation checks if JSON is well-formed (correct brackets, quotes, commas). Schema validation checks if the JSON structure and data types match your expected format. Both are important—syntax validation catches parsing errors, schema validation catches logical errors.

Can I validate JSON without an internet connection?

Yes! Browser console validation, code editor validation, command-line tools, and programmatic validation all work offline. Only online validators require internet. For offline work, our JSON Formatter runs entirely in your browser without sending data to servers.

How do I validate JSON in production without impacting performance?

Use efficient parsers (native JSON.parse() is fast), validate only once when data enters your system, cache validation results for repeated data, and consider async validation for non-critical paths. Most validation adds negligible overhead.

What should I do when validation fails?

Return a clear error message to the client, log the failure with context (user ID, timestamp, invalid data), don't process the invalid data further, and consider implementing retry logic with corrected data for automated systems.

Are there JSON validation libraries for my programming language?

Yes! Every major language has JSON validation libraries. JavaScript has Ajv, Python has jsonschema, Java has json-schema-validator, PHP has justinrainbow/json-schema, and Go has gojsonschema. Choose one that supports JSON Schema for best results.

External Resources

To deepen your JSON validation knowledge:

• JSON Schema Official Site - The standard for JSON validation
• MDN: JSON.parse() - JavaScript JSON parsing documentation
• RFC 8259: JSON Specification - Official JSON format specification
• Ajv JSON Schema Validator - Fast JSON schema validator for JavaScript

The Bottom Line

Validating JSON is one of those things that seems optional until you spend three hours debugging a missing comma. Then it becomes essential.

For quick checks, use an online validator like our JSON Formatter. It's fast, free, and gives you clear error messages with exact line numbers.

For development work, use your code editor's built-in validation. It catches errors as you type and prevents issues before they happen.

For automation and production code, validate programmatically. It's the only way to ensure data quality at scale.

The key is to validate early and often. Don't wait until something breaks. Validate JSON as soon as you receive it, and you'll save yourself hours of debugging. If you're working with JSON files, also check out our guide on how to open and read JSON files properly.

Remember: JSON validation isn't about being paranoid. It's about catching errors before they become problems. A 30-second validation check can save you hours of debugging later.

Want to validate some JSON right now? Head over to our JSON Formatter, paste in your JSON, and click validate. You'll see immediately if there are any errors, and exactly where they are. For comparing JSON files, try our JSON Diff Checker.

Trust me, your future self will thank you for validating now instead of debugging later. And if you need to reduce file sizes, learn how to minify JSON while keeping it valid.