How to Validate JSON with Line Numbers and Detailed Error Positions

I once spent 45 minutes debugging a JSON file that turned out to be missing a single comma on line 247. The validator I was using just said "invalid JSON" with zero context. It was like a car mechanic telling me "something's wrong with your car" and walking away.

That's the moment I realized: not all JSON validators are created equal. A good one tells you it's broken. A great one tells you exactly where and why.

The Three Flavors of JSON Errors

Before we get into tooling, let's categorize the errors you'll actually encounter in the wild:

Syntax Errors

These are the most common and usually the easiest to fix once you know where they are:

{
  "name": "Alice"
  "role": "engineer"  // Missing comma after "Alice"
}

JSON.parse() will throw a SyntaxError here, but the message is often cryptic: "Unexpected string in JSON at position 38". Sure, position 38 is the character index — try counting that in a 500-line file.

Type Errors

Your JSON might be syntactically valid but structurally wrong:

{
  "users": "not_an_array"
}

This passes JSON.parse() but breaks your application because you're expecting users to be an array. These are harder to catch because standard validators won't flag them.

Structural Errors

These happen when the JSON structure doesn't match your expected schema:

{
  "userId": 12345,
  "email": "alice@example.com",
  "address": {
    "city": "New York"
    "zip": "10001"  // Missing comma again!
  }
}

This fails at the nested level, and without line numbers, you're manually scanning braces.

Why Line Number Validation Changes Everything

A validator that pinpoints errors by line number turns debugging from a guessing game into a surgical operation. Here's what I mean:

Without Line Numbers

Error: Unexpected token at position 482

You now need to count 482 characters from the start of your file, accounting for whitespace and newlines. Good luck.

With Line Numbers (What You Want)

// [DevFormatters JSON Formatter](https://devformatters.com/json-formatter.html)
// Error on line 12, column 25: Expected ',' or '}' after property value

{
  "project": "Apollo",
  "version": "2.1.0",
  "dependencies": {
    "express": "^4.18.0",
    "lodash": "^4.17.21"  // <-- line 12, missing comma
    "axios": "^0.27.0"
  }
}

Now I know exactly where to look. Line 12, column 25. I can open my editor, jump to that line, and fix it in seconds.

Building a Simple Line-Aware Validator

To understand how this works under the hood, here's a basic approach:

function validateWithLineNumbers(jsonString) {
  try {
    JSON.parse(jsonString);
    return { valid: true, errors: [] };
  } catch (e) {
    const message = e.message;
    // Extract position from error message
    const posMatch = message.match(/position\s+(\d+)/);
    if (!posMatch) {
      return { valid: false, errors: [{ message }] };
    }
    
    const position = parseInt(posMatch[1]);
    const lines = jsonString.substring(0, position).split('\n');
    const lineNumber = lines.length;
    const columnNumber = lines[lines.length - 1].length + 1;
    
    return {
      valid: false,
      errors: [{
        line: lineNumber,
        column: columnNumber,
        message: message
      }]
    };
  }
}

// Usage
const result = validateWithLineNumbers(malformedJson);
if (!result.valid) {
  console.log(`Error at line ${result.errors[0].line}, column ${result.errors[0].column}`);
}

The key insight: by counting newlines before the error position, you can convert JavaScript's character-based error reporting into something actually useful.

Real Debugging Workflow

Here's how I now handle JSON validation in practice:

Step 1: Paste or upload the JSON file into a client-side validator like DevFormatters. I use client-side tools because I'm often dealing with configs that contain sensitive data.

Step 2: If there's an error, the tool shows me the exact line and column. I don't guess — I navigate directly.

Step 3: I fix the issue and re-validate. This takes about 10 seconds per iteration instead of 5 minutes.

Step 4: For API payloads that need to match a schema, I also check the structure against my expected types using the tree view to spot type mismatches.

Common JSON Errors You'll Hit

Here's a cheat sheet of frequent errors with their line-number patterns:

Error Pattern	What It Means	How to Fix
Unexpected token at line N	Invalid character or missing delimiter	Look for stray commas, unmatched quotes
Expected '}' at line N	Missing closing brace	Check nested objects
Unexpected string at line N	Missing comma between properties	Add comma before the string
Expected ',' or ']' at line N	Similarly, missing comma in array	Check array elements

I keep our team's JSON validation guide bookmarked for onboarding new devs to these patterns.

FAQ

Q: Why does JavaScript's JSON.parse only give me a character position?

A: The ECMAScript spec defines error positions as character indices from the start of the string. It's up to tools to convert that into human-readable line:column format.

Q: Can I validate JSON directly in my terminal?

A: Yes! echo '{"key": "value"}' | python -m json.tool or jq . file.json both give you some error context, though not always line numbers.

Q: What's the best way to validate JSON in CI/CD?

A: Use jq or a Node.js script with JSON.parse() wrapped in a try-catch. For API schemas, tools like Ajv (Another JSON Schema Validator) provide much richer validation.

Q: Does a tree view help with validation?

A: Absolutely. When you can see the structure visually, mismatched braces and missing commas become obvious before you even hit validate. Check our JSON Parse Error guide for more on this.

Q: How do I handle extremely large JSON files during validation?

A: Some validators support streaming to avoid loading the entire file into memory. For most practical files, though, JSON.parse() handles megabytes in milliseconds.

Q: Is there a way to validate JSON schemas beyond syntax?

A: Yes — JSON Schema is a vocabulary that allows you to annotate and validate JSON documents. Libraries like Ajv check both syntax and structure against your schema.

Q: What should I do when the error says "Unexpected token" but I don't see anything wrong?

A: Look for invisible characters (BOM, zero-width spaces, non-breaking spaces). Copy the offending line into a hex viewer or use a tool with character inspection.

Q: Can I validate JSON from a file without copy-pasting?

A: Yes, many client-side formatters support file upload. Try uploading your file directly to skip the copy-paste step entirely.