Forge Json

JSON Lint Online - Free Syntax Checker

Lint JSON online to catch syntax errors, invalid formatting, and parser-breaking characters before the payload reaches code, an API, or a pipeline.

Paste your JSON → Get results instantly (no signup)

⚡ Instant resultsNo signupRuns in your browser
Try examples:

→ Validate this order payload against a small schema config.

{
"order_id": "ORD_1001",
"customer_email": null,
"total_amount": "42.50",
"currency": "USD",
"items": 2
}
Output✓
1{
2  "valid": false,
3  "errors": [
4    {
5      "field": "customer_email",
6      "message": "Expected string, received null"
7    },
8    {
9      "field": "total_amount",
10      "message": "Expected number, received string"
11    },
12    {
13      "field": "items",
14      "message": "Expected array, received number"
15    }
16  ]
17}

Love the result?

Use this exact pipeline in your app, backend, or LLM workflow.

No setup needed. Works with curl, Node, Python.

Uses example data. For edited input, copy from the playground.

Read integration guide

Works with:

  • JSON lint checks
  • Config files
  • API payloads
  • Pre-commit review

Example: input → output

JSON lint online

JSON lint is a quick review pass that checks whether a JSON document is valid, parser-safe, and ready to paste into code, commit to a repository, send to an API, or import into another tool. It catches syntax problems that humans miss during review: trailing commas, single quotes, comments, unquoted keys, invalid numbers, and mismatched brackets.

This page uses the same validation engine as the JSON Schema Validator, but the intent is linting rather than contract validation. First, lint JSON online to make sure the document parses. Then use schema checks only when you need required fields, expected types, or API-specific rules.

How to lint JSON

  1. Paste your JSON document into the input panel.
  2. Run the JSON lint check.
  3. If the parser reports an error, fix the line and column it points to.
  4. Rerun the linter until the JSON parses cleanly.
  5. Continue with formatting, cleanup, diffing, conversion, or schema validation.

Linting is most useful before a handoff. It gives you a quick yes/no syntax check before someone else receives the payload.

When to use a JSON linter

  • Before committing a config file.
  • Before pasting JSON into a backend test, curl command, or API client.
  • Before importing a sample payload into a data pipeline.
  • Before sending webhook examples to another team.
  • Before running the JSON Formatter, JSON Diff Tool, or JSON to CSV Converter.

If you already know the document is broken, use Fix Invalid JSON for parser-error repair. If your search is simply "validate JSON online," use Validate JSON Online.

JSON lint vs JSON formatter

A JSON formatter changes the presentation of valid JSON. A JSON linter checks whether the text is valid enough to format safely. That is why linting should come first: invalid JSON cannot be reliably pretty-printed, converted, diffed, or schema-validated.

After the lint check passes, use the formatter or cleaner to trim strings, sort keys, remove empty fields, and standardize the document for downstream use.

Common JSON lint errors

  • Trailing commas after the final object or array item.
  • Single-quoted strings copied from JavaScript examples.
  • Unquoted keys that look valid in JavaScript but fail standard JSON.
  • Comments from JSONC or config-style snippets.
  • Invalid numbers such as NaN, Infinity, 5., or 007.
  • Missing brackets after copying only part of a payload.

Frequently asked questions

What does JSON lint mean?+

JSON lint means checking a JSON document for syntax errors before it is committed, imported, sent to an API, or passed into another tool.

Is JSON lint different from formatting?+

Yes. A linter checks whether the JSON parses. A formatter changes the appearance of already-valid JSON. Lint first, format after the syntax passes.

What JSON lint errors does this catch?+

It catches trailing commas, single quotes, unquoted keys, comments, invalid numbers, control characters, and mismatched brackets.

Can I lint JSON without uploading it?+

Yes. The lint check is designed for browser-based review before the payload moves into code, an API, or a pipeline.

What should I do after JSON lint passes?+

Format or clean the JSON, compare it with JSON Diff, convert it to CSV, or validate its structure with JSON Schema.

Related tools

Read more on the blog

Advanced usage (optional)

Schema Validation

v1.0.0
Validation
objectarraystringreversible

Description

Schema Validation

Validate JSON against a JSON Schema-style subset and return a field-level report.

This utility is a report-producing transformer. It does not block, skip, warn, or otherwise control pipeline execution. Use validation.contract when a pipeline needs guardrail behavior.

Supported V1 Schema Fields

  • type: object, array, string, number, boolean, or null
  • required: array of required object keys
  • properties: object field rules
  • items: array item rule
  • enum: primitive values only, using strings, numbers, booleans, or null

Unknown fields are ignored in V1.

Invalid schema config returns:

{
  "valid": false,
  "errors": [
    { "field": "$schema", "message": "Missing or invalid schema config" }
  ]
}

Configuration

NameTypeDefaultDescription
Schema Configjson{"type":"object","required":[],"properties":{}}JSON Schema-style subset. Supports type, required, properties, items, and primitive enum values. Unknown fields are ignored in V1.

Examples

AI Prompt
Validate this order payload against a small schema config.
{
"order_id": "ORD_1001",
"customer_email": null,
"total_amount": "42.50",
"currency": "USD",
"items": 2
}
Output✓
1{
2  "valid": false,
3  "errors": [
4    {
5      "field": "customer_email",
6      "message": "Expected string, received null"
7    },
8    {
9      "field": "total_amount",
10      "message": "Expected number, received string"
11    },
12    {
13      "field": "items",
14      "message": "Expected array, received number"
15    }
16  ]
17}
Config
Schema Config
1{
2  "type": "object",
3  "required": [
4    "order_id",
5    "customer_email",
6    "total_amount",
7    "currency",
8    "items"
9  ],
10  "properties": {
11    "order_id": {
12      "type": "string"
13    },
14    "customer_email": {
15      "type": "string"
16    },
17    "total_amount": {
18      "type": "number"
19    },
20    "currency": {
21      "type": "string",
22      "enum": [
23        "USD",
24        "EUR",
25        "GBP"
26      ]
27    },
28    "items": {
29      "type": "array",
30      "items": {
31        "type": "object",
32        "required": [
33          "sku",
34          "qty"
35        ],
36        "properties": {
37          "sku": {
38            "type": "string"
39          },
40          "qty": {
41            "type": "number"
42          }
43        }
44      }
45    }
46  }
47}

API Usage

POST /api/v1/utilities/validation.schema
Example:
curl -X POST https://your-domain.com/api/v1/utilities/validation.schema \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"inputs":{"primary":{"order_id":"ORD_1001","customer_email":null,"total_amount":"42.50","currency":"USD","items":2}},"config":{"schema":{"type":"object","required":["order_id","customer_email","total_amount","currency","items"],"properties":{"order_id":{"type":"string"},"customer_email":{"type":"string"},"total_amount":{"type":"number"},"currency":{"type":"string","enum":["USD","EUR","GBP"]},"items":{"type":"array","items":{"type":"object","required":["sku","qty"],"properties":{"sku":{"type":"string"},"qty":{"type":"number"}}}}}}}}'
Response
1{
2  "valid": false,
3  "errors": [
4    {
5      "field": "customer_email",
6      "message": "Expected string, received null"
7    },
8    {
9      "field": "total_amount",
10      "message": "Expected number, received string"
11    },
12    {
13      "field": "items",
14      "message": "Expected array, received number"
15    }
16  ]
17}