URL decoding turns percent-encoded text like Hello%20World%21 back into the readable string Hello World!, and Notepad++ can do it through the MIME Tools plugin once it is installed and enabled. The plugin reads percent-encoding the same way browsers do, replacing each %HH sequence with the byte it represents after UTF-8 decoding, so spaces, accents, emoji and CJK characters all return to their original form when the input is valid. If the input contains a stray %, a non-hexadecimal pair like %zz, or a cut-off multi-byte sequence, the plugin stops and flags the bad characters rather than silently handing back a corrupted string. Many people search for this exact workflow because Notepad++ ships without a built-in URL decoder, so installing the plugin is the first hurdle. For users who want the same accuracy without the plugin setup, a browser-based URL Decoder runs the same transformation locally and gives instant results on any text you paste.
Why Notepad++ Needs a Plugin to Decode URLs
Notepad++ is a general-purpose text editor built on Scintilla. Out of the box it can search, replace, fold, mark syntax and run regular expressions against any text you load, but URL encoding and decoding are not part of the core feature set. The editor handles raw bytes correctly when you set the document encoding to UTF-8, but it never interprets %HH sequences for you. That is why every recipe for "decode URL in Notepad++" revolves around an external plugin, most often MIME Tools.
The gap is easy to overlook because Notepad++ has plugins for Base64, URL, hex and even ROT13 scattered across its plugin catalogue. Some plugins have shipped only with older releases, some are 32-bit only, and some require manual download of a .dll from a third-party GitHub repository. The end result is that a task which should take one paste and one click can easily turn into a version hunt. Recognising this is the first step: if you opened Notepad++ expecting a Tools menu entry for URL decode, you will not find one in a clean install.
Decoding a URL in Notepad++ with the MIME Tools Plugin
The MIME Tools plugin is the route that keeps you inside Notepad++ for the whole job. It adds Base16, Base64, Quoted-Printable and URL encoding entries under the Plugins menu and follows the same percent-encoding rules browsers use, backed by the same JavaScript-style encodeURIComponent and decodeURIComponent logic the URL Decoder uses.
- Open Notepad++ and confirm the document encoding is set to UTF-8 via the Encoding menu, because percent-encoded multi-byte characters only decode correctly when the editor reads the file as UTF-8.
- Open Plugins → Plugins Admin, search for MIME Tools, tick the box next to it and click Install. Notepad++ will restart so the plugin can load.
- Paste the percent-encoded URL or query string into a new tab. An example you can test against is Hello%20World%21 which should decode to Hello World!.
- Select the text you want to decode. If the whole line is percent-encoded, press Ctrl+A to select everything in the tab.
- Open Plugins → MIME Tools → URL Decode. The plugin replaces each %HH sequence with the matching byte and rewrites the selection in place.
- Verify the result visually. The character that was %20 should now read as a space, %21 as an exclamation mark, and any %E4%B8%AD%E6%96%87 (Chinese for "Chinese") should collapse to the two CJK characters.
If the plugin reports an error instead of writing a result, the most common cause is that the document encoding was not UTF-8, the selection contains a stray percent sign, or the plugin was loaded against a 64-bit build of Notepad++ where the 32-bit .dll cannot register. Switching to UTF-8 and reinstalling the matching architecture plugin resolves both cases.
Limits of the Plugin Approach
The MIME Tools route works, but it has three friction points that push many users to look for something else. First, the plugin is officially distributed only for 32-bit Notepad++. If you run the 64-bit build, you have to source the .dll from a community repository and place it manually under %ProgramFiles%\Notepad++\plugins\ before restarting. Second, the plugin does not separate "URL component" encoding from "full URL" encoding, so it can over-escape characters that are part of the address structure or under-escape characters that some servers treat as reserved. Third, there is no preview: the plugin rewrites your selection in place, so a wrong move on a large file means you have to undo and try again.
For quick one-off jobs on a single line this is fine. For repeated decoding of query strings, OAuth callback URLs, or analytics parameters, the friction adds up, and that is the moment a browser-based tool becomes worth opening in another tab. Readers who would like a code-free alternative can follow the guide to decoding a URL in your browser without writing code for a step-by-step walkthrough.
How to Decode a URL in the Browser with the URL Decoder
The URL Decoder runs the same percent-decoding logic in your browser using the built-in decodeURIComponent and decodeURI routines, which means the result you see matches what a compliant server would produce. Nothing is uploaded, there is no account, and the tool keeps working once the page has loaded even if you go offline.
- Open the URL Decoder and choose a scope. Pick URL component when you are decoding a single query value, path segment, or fragment, or Full URL when the input is a complete address and you only want unsafe characters handled.
- Set the direction to Decode so percent-encoded text is converted back to readable characters.
- Paste your text into the input box. The result updates as you type, so you can watch each %HH sequence collapse into its byte in real time.
- Read the output. If anything in the input is malformed, the tool stops with a clear error explaining what is wrong, instead of returning a half-decoded string.
- Click Copy to put the decoded text on your clipboard, ready to paste into a config file, an analytics tool, or the body of an HTTP request.
A quick worked example: paste Hello%20World%21 into the input. The decoder reads %20 as a single space (hex 20 is the ASCII code for space) and %21 as an exclamation mark (hex 21), and the output box shows Hello World!. A second example, %E4%B8%AD%E6%96%87, decodes to the two CJK characters meaning "Chinese", which confirms the UTF-8 round trip is intact.
How Percent-Encoding Actually Works
Percent-encoding is defined in RFC 3986 as a way to represent characters inside a URI using only ASCII letters, digits and a small set of punctuation. Every character that is not "unreserved" (A-Z, a-z, 0-9, hyphen, dot, underscore, tilde) and is not a delimiter needed for the URI structure must be written as %HH, where HH is the two-digit hexadecimal value of the byte. UTF-8 is used for non-ASCII characters, so a single character can expand into several percent groups.
| Character | Reason it gets encoded | Percent-encoded |
|---|---|---|
| Space | Not allowed unescaped in URLs | %20 |
| ! | Sub-delim, reserved by some schemes | %21 |
| # | Starts the fragment segment | %23 |
| & | Separates query parameters | %26 |
| + | Legacy form for space in query strings | %2B |
| / | Path segment separator | %2F |
| ? | Begins the query component | %3F |
| = | Separates key from value in a query pair | %3D |
| % | The escape character itself | %25 |
Component mode escapes every row in this table, including the slash and the equals sign, so the encoded value can never be mistaken for part of the surrounding URL structure. Full-URL mode keeps the structural characters intact and only escapes the genuinely unsafe ones like space and non-ASCII letters, which is why the same tool gives different output depending on which mode you pick.
Decode Errors You Will Hit and What They Mean
Decoding is strict, and three malformed inputs trip most tools up. A lone percent sign with nothing after it cannot be decoded because there is no HH pair. A percent followed by characters that are not hexadecimal digits, like %zz or %G1, is also invalid. A truncated multi-byte sequence, where a UTF-8 lead byte is present but the continuation bytes are missing or wrong, breaks the decode as well.
The URL Decoder surfaces each of these as a specific error rather than silently returning the part of the string it could parse, which is the right behaviour because a half-decoded value shipped downstream looks correct but is corrupted. The fix is almost always in the source: locate the stray %, the non-hex pair, or the cut-off byte sequence, repair the original string, and decode again.
For developers and testers who hit these errors regularly, the safest workflow is to keep the URL Decoder open in a browser tab as a quick sanity check whenever a query string, a callback URL or a tracking parameter does not look right. Because processing is local, sensitive tokens, internal redirects and personal data stay on your machine while you debug, which is a stronger privacy guarantee than pasting the same string into a hosted web service.