Skip to main content
Encoders

Percent Encoding Decoder

Decode one percent-encoded UTF-8 string locally with decodeURIComponent, treating plus signs as spaces, and report invalid escape sequences instead of returning partial output. Essential for developers debugging URL parameters, parsing form submissions, and inspecting encoded API query strings.

URL tools

In brief

The decoder first maps every + to a space and then applies decodeURIComponent to the entire input; that is useful for form-style data but can change literal plus and URI delimiters.

What this tool supports

  • Replaces every plus sign with U+0020 SPACE, then decodes valid UTF-8 percent triplets across the entire input with JavaScript decodeURIComponent.
  • Rejects incomplete %, non-hex triplets, and percent bytes that cannot form valid UTF-8, returning no partial decoded output.
  • Accepts typed, pasted, or imported text, updates output continuously regardless of the cosmetic Live toggle, and supports copy/download.
  • Uses URLSearchParams on the original input to count repeated query values for the status line; this count is informational and does not drive decoding.

How to use Percent Encoding Decoder

Follow this implementation-specific workflow for Percent Encoding Decoder; each step reflects the controls and limits in the current browser workspace.

  1. 1

    Step 1

    Provide the exact source

    Paste the encoded component or form-style value exactly; decide first whether literal + should remain plus or represent space.

  2. 2

    Step 2

    Choose the operation

    Use the whole-string decoder only when turning escaped delimiters back into characters is intended.

  3. 3

    Step 3

    Configure the available options

    The output updates immediately as + becomes space and decodeURIComponent converts percent-encoded UTF-8 bytes.

  4. 4

    Step 4

    Run the local operation

    Stop on any invalid-sequence error and repair the source rather than deleting percent characters until it happens to decode.

  5. 5

    Step 5

    Verify and continue

    Compare the decoded text with the expected Unicode value before copying or downloading decoded-url.txt.

Common mistakes

Decoding a literal plus sign as if it were preserved

Consequence: This implementation always changes + to space before decodeURIComponent, following form-query convention rather than generic URI percent decoding.

Fix: Encode a literal plus as %2B before decoding or use a decoder that does not apply form semantics.

Decoding an entire URI before separating components

Consequence: Escaped %2F, %3F, %23, or %26 can become structural delimiters and change how a URI is parsed.

Fix: Split and validate the URI into scheme/authority/path/query/fragment, then decode only the intended component.

Decoding the same string twice

Consequence: A first pass can expose new % sequences or delimiters, and a second pass can change meaning or enable unsafe interpretation.

Fix: Track encoding layers and decode exactly once at the correct protocol boundary.

Best practices

  • Preserve the raw encoded input for audit and compare it with the single-pass result.
  • Validate security-sensitive values after decoding because checks on encoded text can miss separators or NUL-like data.
  • Use a component-aware parser before decoding complete URLs and distinguish generic URI encoding from application/x-www-form-urlencoded.

Connected workflows

Decode and validate a URI component safely

Percent Encoding DecoderURL Validator

Preserve the raw value, identify component/form semantics, decode once, then validate the resulting text before use.

  1. Keep raw encoded input
  2. Identify plus and component semantics
  3. Decode exactly once
  4. Inspect Unicode and delimiters
  5. Validate destination syntax

Browser limitations

  • Every plus becomes space even outside a query/form value; there is no switch for literal-plus behavior.
  • The entire string is decoded at once, so reserved delimiters are not protected by URI component boundaries.
  • Output is a JavaScript string; arbitrary binary octets, non-UTF-8 encodings, and partial recovery from malformed input are unsupported.

Authoritative resources

RFC 3986: Uniform Resource Identifier (URI) Generic SyntaxPublisher: IETF / RFC Editor · Reviewed: 2026-07-26encodeURIComponent()Publisher: MDN Web Docs · Reviewed: 2026-07-26

Concrete examples

Input
caf%C3%A9+%26+tea
Result
UTF-8 bytes C3 A9 become é, each plus becomes a space, and %26 becomes an ampersand.

The implementation performs input.replace(/\+/g, " ") before decodeURIComponent, so this is form-style plus handling plus percent decoding.

Frequently asked questions

Why did a plus sign turn into a space?

The tool deliberately applies form-query convention before decodeURIComponent. Use %2B when the desired decoded character is a literal plus.

What causes the invalid percent-encoded sequence error?

A stray/incomplete %, non-hex digits, or percent bytes that are not valid UTF-8 make decodeURIComponent throw; the tool returns no partial result.

Can I safely decode a full URL with this?

Only if you intend all escaped delimiters to become structural characters. RFC 3986 recommends separating components before decoding them.

Does the query-value count describe the decoded output?

Not necessarily. It parses the original input with URLSearchParams for a status hint; a fully percent-encoded URL may not expose its query before decoding.

Will the decoder visit or validate the resulting URL?

No. It produces plain text only; use URL Validator before navigation or security decisions.

Privacy and offline behavior

Encoded input and decoded output stay in this browser and are not fetched as a URL. File import, clipboard copy, and download occur only after explicit actions, and decoding works offline once app assets are cached.