Is this the same as decodeURIComponent?

Yes, it calls the browser's built-in decodeURIComponent function directly, with no extra leniency or custom parsing on top, so behavior matches exactly what you'd see running it in your own JavaScript code, in a browser console, or in Node.js. That includes both the successful case, where every %XX sequence resolves into its original character, and the failure case, where a malformed sequence causes the function to throw rather than return a best-effort guess. It's a direct call to the same standardized function every JavaScript engine implements, so there's no risk of this tool's output diverging from what your production code would produce for the same input. If you're debugging a decoding discrepancy, whatever this tool shows is exactly what decodeURIComponent(yourString) would return.

What happens if the input isn't validly encoded?

A malformed percent sequence, say a % not followed by two valid hexadecimal digits (100%zz), a lone % at the end of the string (50% off), or a truncated multi-byte UTF-8 sequence (%E2%98 with no final byte), causes decodeURIComponent to throw a URIError with the message "URI malformed". Rather than catching that and silently returning the original text or a mangled guess, the tool surfaces it as a clear invalid-input error: "Input contains an invalid percent-encoding sequence." That's deliberate. Guessing at what a broken percent-sequence was supposed to mean would hide a real bug, usually a value that got truncated in transit, corrupted by a lossy copy-paste, or never properly encoded in the first place.

Can I decode a full URL with this?

You can, but it's safer to decode individual query values one at a time. Decoding a full URL will also unescape any characters that were deliberately percent-encoded to keep the URL structure intact - for example a %2F inside a path segment that represents a literal slash character in the data, not a path separator. Decode the whole URL at once and that %2F becomes an indistinguishable / in the output, and you lose the information needed to tell which slashes were structural and which were part of the original value. Decoding one query parameter or path segment at a time keeps that distinction clear and avoids reconstructing a URL that looks different from the one you started with.

Why does + not turn into a space?

That's a form-encoding (application/x-www-form-urlencoded) convention, not standard percent-encoding. Percent-encoding, the RFC 3986 mechanism this tool implements, always represents a space as %20 and has no special rule for the + character, so decodeURIComponent leaves any + in the input completely untouched. application/x-www-form-urlencoded, used by HTML forms and by the query string portion of many form-submitted URLs, is a separate, older encoding scheme layered on top that does treat + as a space. If your input came from a submitted HTML form rather than directly from a URL path or a manually built query string, convert any + to a space yourself before decoding here, otherwise it'll pass through literally.

Is my data uploaded to a server when I decode it?

No. Decoding happens entirely inside your browser, using the same built-in decodeURIComponent function every JavaScript runtime ships with. There's no backend call this page makes to process your input, and the text you paste is never transmitted, logged, or stored anywhere. Useful to know if you're decoding something sensitive: an access token embedded in a redirect URL, an internal API path, a session identifier copied from a log line, none of it leaves your machine. You can verify this yourself by watching your browser's network panel while decoding - there's no request carrying the string you typed, because the whole operation runs locally in memory.

How does this relate to the URL Encoder tool?

They're inverses. The URL Encoder turns unsafe characters into %XX sequences, and this tool reverses that back into readable text. Encoding a string and then decoding the result should always return exactly what you started with, which makes the pair useful for a round-trip sanity check when you're debugging a URL-handling bug: encode a suspected value, decode it again, confirm it matches. If it doesn't match, the input to the decoder was probably encoded more than once (each decode pass only removes one layer), or the value passed through a different encoding convention, like form encoding, somewhere else in the pipeline before it reached you.

What happens with a truncated or corrupted multi-byte character?

It fails the same way any other malformed sequence does, with a URIError, surfaced by this tool as an invalid-input message, rather than a partially decoded or garbled character. Non-ASCII characters are represented as multiple consecutive %XX bytes under UTF-8 (☕ is %E2%98%95, three bytes, for example), and decodeURIComponent needs every byte of that sequence to reconstruct the character correctly. If a copy-paste, a truncated log line, or a buggy encoder drops one of those bytes, leaving %E2%98 with no third byte, there's no valid character the decoder can produce, so it throws instead of returning something that looks plausible but is actually wrong. That fail-loud behavior is intentional: a silently wrong character is a lot harder to catch than an explicit error.

Does this follow the same spec as the URL Encoder tool?

Yes. Both tools implement percent-encoding as described in RFC 3986, the URI generic syntax specification, using the pair of ECMAScript functions, encodeURIComponent and decodeURIComponent, that browsers and Node.js implement identically. The WHATWG URL Standard, which governs how browsers actually parse and normalize full URLs today, defines its own percent-decode algorithm that's compatible with this for well-formed input, though it's used in a slightly different context, parsing a complete URL rather than decoding a single already-isolated value. For decoding an individual query parameter or path segment, which is what this tool is for, decodeURIComponent's behavior is the practical standard, and it's exactly what you'd get calling the same function directly in your own code.

URL Decoder - Decode Percent-Encoded Text Online

Overview

Introduction

Copy a link out of a browser's address bar or an API log and you'll often see %20, %2F, and similar sequences standing in for spaces and punctuation. This tool reverses that encoding so you can read or reuse the original text.

It's most useful when you're staring at a raw access log, a webhook payload, or a redirect URL and just need to know what value is actually being carried, rather than mentally decoding %XX sequences one at a time.

What Is URL Decoder?

URL decoding reverses percent-encoding: each %XX sequence gets interpreted as a hexadecimal byte, and the resulting bytes are decoded back into text.

It's the mirror image of URL encoding. Anywhere text was escaped to survive being embedded in a URL, this recovers the original characters, including reserved ones like & and + that only look structural until they're decoded.

How URL Decoder Works

The tool passes your input through the browser's native decodeURIComponent function, which interprets each percent-encoded byte sequence as UTF-8 and reconstructs the original characters, throwing an error if a sequence is malformed.

Because decoding is byte-oriented, multi-byte UTF-8 sequences (used for non-ASCII characters like emoji or accented letters) get reassembled correctly as long as every constituent %XX byte is present. A truncated or corrupted sequence is exactly what triggers the malformed-input error instead of returning garbled text.

When To Use URL Decoder

Use it to read a percent-encoded query string from server logs, inspect a copied redirect URL, or verify that a value you encoded elsewhere decodes back to what you expect.

It also helps when debugging integrations: if an API returns a percent-encoded value where you expected plain text, decoding it here quickly tells you whether the encoding itself is the bug or just an intermediate representation.

Often used alongside URL Encoder.

Features

Advantages

Runs entirely client-side, so pasted URLs or tokens never leave your browser.
Surfaces malformed encoding as a clear error instead of silently producing garbled text.
Matches native browser decoding behavior exactly.

Limitations

Doesn't convert + to a space - that's a separate, form-encoding-specific convention.
Decoding an already-decoded string does nothing useful, since there's no percent-encoding left to interpret.

Percent-Decoding vs. Form Decoding

Percent-Decoding vs. Form Decoding
	Percent-decode (this tool)	Form decode (application/x-www-form-urlencoded)
Converts %20 to a space	Yes	Yes
Converts + to a space	No	Yes
Used for	Query string and path values	HTML form submissions

Examples

Decoding a query string value

Input

c%2B%2B%20tutorials%20%26%20guides

Output

c++ tutorials & guides

Each %XX sequence converts back to its original character, including reserved characters like + and &.

Decoding non-ASCII text

Input

caf%C3%A9%20%E2%98%95%20%E6%97%A5%E6%9C%AC%E8%AA%9E

Output

café ☕ 日本語

Consecutive %XX bytes are interpreted together as UTF-8 and reassembled into the original multi-byte characters.

A malformed percent sequence

Invalid input

100%zz

Parser error

Error: Input contains an invalid percent-encoding sequence.

%zz isn't a valid hexadecimal byte, so decodeURIComponent throws a URIError instead of guessing what the character was meant to be. The fix is to correctly encode any literal % as %25.

Corrected version

100%25zz

A literal plus sign

Input

a+b

Output

a+b

Percent-decoding has no special rule for +, so it passes through unchanged; only form-encoded (application/x-www-form-urlencoded) values treat + as a space.

Best Practices & Notes

Best Practices

Decode individual query parameter values rather than an entire URL to avoid corrupting the URL's structural characters.
If you're processing form submissions, convert + to a space before decoding, since that's a separate convention this tool doesn't apply.
Pair with the URL encode tool to sanity-check round-trips while debugging.
When a decode fails, check the exact position of the reported % first; a truncated copy-paste or a log line cut off mid-sequence is the most common cause.
Treat a decoding error as a signal to inspect the source of the value, not something to work around by stripping the stray % and re-decoding. That usually just hides a real upstream bug.

Developer Notes

This wraps the native decodeURIComponent function with no additional leniency layered on top, so a malformed sequence throws exactly as it would in your own code. decodeURIComponent processes the input as a sequence of UTF-8 bytes: each %XX is decoded to a raw byte, consecutive bytes belonging to the same multi-byte UTF-8 character are combined, and the result is reassembled into a JavaScript string. Any byte sequence that isn't valid UTF-8, whether from a truncated multi-byte character or a random invalid hex pair, causes the function to throw a URIError rather than substitute a replacement character, which is why this tool reports a clear error instead of ever returning mangled or partially decoded text.

URL Decoder Use Cases

Reading a percent-encoded query string copied from a server access log
Inspecting a redirect URL to see what value it actually carries
Verifying that an encoded value round-trips correctly during debugging
Diagnosing whether an unexpected %XX sequence in application data is the bug, or just an intermediate encoded representation

Common Mistakes

Assuming + will decode to a space. It won't, since that's a form-encoding rule, not part of percent-decoding.
Decoding a string that was never encoded, which just returns the same text unchanged and can mask a different bug.
Decoding a full URL instead of a single value, which also unescapes characters that were deliberately encoded to preserve the URL's structure.
Treating a decoding error as random noise instead of a sign of truncated or corrupted input worth tracing back to its source.

Tips

If decoding throws an 'invalid' error, check for a stray % that isn't followed by two hex digits.
Use the encode tool on the output afterward to confirm you get back exactly the string you started with.
If a value contains %XX sequences that don't decode to anything readable, confirm it wasn't encoded twice before assuming it's genuinely malformed.

URL Decoder

Overview

Introduction

What Is URL Decoder?

How URL Decoder Works

When To Use URL Decoder

Features

Advantages

Limitations

Percent-Decoding vs. Form Decoding

Examples

Decoding a query string value

Decoding non-ASCII text

A malformed percent sequence

A literal plus sign

Best Practices & Notes

Best Practices

Developer Notes

URL Decoder Use Cases

Common Mistakes

Tips

References

Frequently Asked Questions