String to JSON Parser Online — Unescape Stringified JSON

Unescape backslash-quoted JSON, parse double-stringified API payloads, decode \u escapes, and pretty-print the result. Built for debugging real-world API responses and log lines — 100% in your browser.

Input String

Parsed JSON

What is a string to JSON parser?

A string to JSON parser takes a JSON-encoded string — quoted, with backslash-escaped \" sequences and possibly \n, \t, or \u escapes — and turns it back into a real JSON document. It is the operation you need when an API returns a JSON-wrapped JSON string, when a database column stores serialised JSON as TEXT, or when a log line embeds a payload as an escaped string.

If you have ever copy-pasted an API response into a JSON formatter only to be told "invalid JSON", you have probably hit a stringified payload. The trick is to unescape the outer quotes and backslashes first, then parse the inner content. This tool does both passes automatically.

How to parse a stringified JSON payload — 4 steps

Paste the escaped string. Include the outer quotes if your source has them, and keep all \" sequences intact.
Click Convert. The parser tries JSON.parse twice — first to unwrap the outer string, then to parse the inner JSON.
Read the result. Output is pretty-printed with 2-space indentation, real line breaks, and decoded Unicode escapes.
Re-run if nested. If the result is still a quoted string, paste it back in to peel off another layer of escaping.

Sample stringified JSON and parsed output

A double-stringified API payload with escaped quotes, a Unicode escape, and nested objects:

Input (escaped string)

"{\"id\":42,\"user\":\"ada\",
  \"meta\":{\"city\":\"London\",
  \"emoji\":\"\u2728\"},
  \"tags\":[\"admin\",\"beta\"],
  \"active\":true,
  \"score\":null}"

Parsed JSON

{
  "id": 42,
  "user": "ada",
  "meta": {
    "city": "London",
    "emoji": "✨"
  },
  "tags": [ "admin", "beta" ],
  "active": true,
  "score": null
}

Smart Double-Parse

Calls JSON.parse once to unwrap the outer string. If the result is still a string, parses again to recover the real object.

Unicode-Aware

Native browser JSON parsing decodes \u escapes — including surrogate pairs for emoji and characters outside the BMP.

Browser-Only

JSON.parse is a built-in. No SDK, no upload, no library. Tokens, IDs, and PII in your payload stay on your machine.

Common use cases

check_circleDebugging an API response where one field contains a stringified JSON payload
check_circleInspecting a database TEXT column that holds serialised JSON
check_circleReading a log line where an event payload was JSON.stringify-ed before logging
check_circleDecoding a JSON string passed as a URL query parameter
check_circleUnwrapping AWS SNS / SQS / EventBridge messages whose Body is a JSON string
check_circleInvestigating webhook payloads from Stripe, Shopify, or GitHub that nest JSON
check_circlePulling the inner JSON from a JWT payload claim that was double-encoded
check_circleReviewing a Postman / Insomnia history entry where the body was logged as a string

Single vs double JSON.parse — when do you need each?

A normal JSON document — an object, array, number, etc. — is parsed in one call. A stringified JSON document is the same data wrapped in extra quotes with \" escapes, and it parses to a string; you have to call JSON.parse a second time on that string to recover the object. This double-parse pattern is so common in API debugging that the OpenFormatter parser detects it automatically: if the first parse yields a string, the tool runs a second pass instead of returning a useless one-line string.

Need to go the other way or just format?

Pretty-print regular JSON, escape JSON into a string, or validate against well-formedness — same toolkit.

JSON Formatter JSON to String JSON Validator

Frequently Asked Questions

What is the difference between JSON.parse and unescape-then-parse?

JSON.parse expects a JSON document — an object, array, number, boolean, null, or string literal. If the document is a JSON string whose value is itself a serialised JSON object (a "double-stringified" payload), JSON.parse returns the inner string and you have to call JSON.parse again. This tool detects that case automatically: if the first parse yields a string, it parses a second time.

How do I handle escaped Unicode like \u00e9 or \u2728?

JSON.parse handles \u escapes natively — once your text is valid JSON, \u00e9 becomes é and \u2728 becomes the sparkles emoji. The tool relies on the browser's native parser, so any code point that JSON.parse accepts is decoded correctly, including surrogate pairs for emoji outside the Basic Multilingual Plane.

Why does my API return a JSON-wrapped JSON string?

A common pattern: the response is application/json, but a field like "payload" contains a stringified JSON object instead of a nested object. This usually happens when a backend stores the field as TEXT in a database and re-serialises it on the way out, or when a message bus carries opaque payloads. Paste the field value here to see the real shape.

Can the tool handle escaped newlines and tabs?

Yes. \n in the source becomes a real line break, \t becomes a tab, \r becomes a carriage return, and \\ becomes a single backslash. Once the string is unescaped, the JSON parser pretty-prints with consistent 2-space indentation regardless of how the source was formatted.

What if the string has mixed escapes — some \" and some \\\"?

That happens with triple-stringified payloads (rare but real, common in some logging pipelines). Run the converter once to peel off the outer layer; then paste the result back in and run again. Each pass removes one level of escaping until you reach the original JSON.

Is this the same thing as JSON validation?

No — but it is a related step. JSON validation checks whether a document is well-formed JSON. This tool first un-stringifies a wrapped string, then parses the inner content. If you only need to check well-formedness of plain JSON, the JSON Validator is faster.

Will my data be uploaded to a server?

No. Everything runs in JavaScript inside your browser — JSON.parse is a built-in, no library needed. Tokens, IDs, and user data in your payload never leave your machine. Open DevTools → Network and confirm zero requests are made on Convert.

How is this different from a JSON formatter?

A JSON formatter pretty-prints already-valid JSON. This tool first removes a layer of string escaping (handling backslash-quoted JSON, double-serialised payloads, and \u escapes) and then formats the result. Use it when JSON.parse on the raw input gives you a string instead of an object.