Decode encoded URLs or convert text into URL safe characters with Nimzoa's free URL Encoder & Decoder. Choose between URL Component and Full URL modes, see results instantly, and copy your converted text. All processing happens directly in your browser.
Browser-based developer tool
Convert text for a URL component or a full URL as you type. Your input stays in your browser.
Use URL Component for individual query parameter values. Full URL preserves structural characters such as /, ?, & and =. This is encoding, not encryption or URL validation.
No uploads, accounts or external processing APIs. Nimzoa does not store the text entered here.
How it works
Select Encode to convert text into a URL safe representation, or Decode to turn percent-encoded text back into readable characters.
Choose URL Component for individual parameter values, or Full URL to preserve the URL structure. Enter or paste your text to see the converted result instantly.
Review the encoded or decoded output, then click Copy Output to use it in your URL, query parameter, or development workflow.
Nimzoa's free URL Encoder & Decoder is an online developer utility for converting text between readable characters and percent-encoded URL representations. It helps developers, website owners, SEO professionals, marketers, and everyday internet users work with URLs, query parameters, special characters, and Unicode text without manually replacing characters. URL encoding, also known as percent encoding, represents certain characters using a percent sign followed by hexadecimal values. For example, a space can become %20, an ampersand can become %26, and an equals sign can become %3D when encoded as part of a URL component. URL decoding reverses these representations to recover readable text when the encoded sequence is valid. The tool supports two conversion scopes: URL Component and Full URL. URL Component mode is useful for individual query-parameter values or other URL components because it encodes characters that could otherwise be interpreted as URL separators. Full URL mode preserves many structural characters, such as slashes, colons, question marks, and ampersands, while encoding characters that require conversion. These modes correspond to common JavaScript URL encoding and decoding functions. You can switch between Encode and Decode, type or paste text, and inspect the result as you work. Convenient controls let you paste input, clear the workspace, swap the input and output, and copy the converted result. The tool also includes a query-parameter example to demonstrate how encoded values are used in real URLs. Nimzoa supports Unicode text, including international characters and emoji, through the browser's encoding functions. This makes it useful when working with multilingual URLs, API parameters, search queries, campaign tracking links, and web application data. URL encoding is not the same as encryption. It does not hide sensitive information or make an unsafe URL secure. Similarly, encoding text does not verify that a complete URL is correctly constructed or that a destination is trustworthy. All text conversion happens locally in your browser. Nimzoa does not require an account, upload your input for processing, or send the text to an external conversion API. The tool is designed for quick, practical URL conversions on desktop and mobile devices. Whether you need to decode a percent-encoded link, encode a search parameter, investigate a malformed URL, or understand the difference between full URL and component encoding, Nimzoa provides a straightforward workspace for completing the conversion.
Encode and decode URLs instantly in your browser without registration or uploads. Choose URL Component or Full URL processing, work with Unicode and special characters, and view results as you type. Paste, clear, swap, and copy text with convenient controls. A built-in query parameter example helps explain common URL encoding behavior.
Your input and converted output are processed locally in your browser. Nimzoa does not upload or store the text you enter or send it to an external processing API. URL encoding is not encryption, so avoid sharing sensitive information through URLs.
A URL decoder converts valid percent encoded text into readable characters. For example, hello%20world becomes hello world. Nimzoa lets you decode URL components or full URLs directly in your browser.
Select Decode, choose URL Component or Full URL, and enter the encoded text. Nimzoa displays the converted result as you type, and you can copy it when finished.
URL encoding, also called percent encoding, represents certain characters using a percent sign followed by hexadecimal digits. It helps distinguish text values from special URL syntax.
encodeURI preserves many structural URI characters, including slashes and question marks. encodeURIComponent encodes more reserved characters and is generally suitable for individual parameter values.
decodeURI preserves certain percent-encoded reserved characters in a complete URI, while decodeURIComponent decodes those characters when they belong to an individual component.
Percent encoding commonly represents a space as %20. Form-style query serialization can use + instead. JavaScript's decodeURIComponent does not automatically turn a literal plus sign into a space.
Yes. Nimzoa uses browser-based encoding functions that support Unicode text, including accented letters, international scripts, and emoji.
Decoding may fail if the input contains incomplete percent sequences, invalid hexadecimal characters, or malformed UTF-8 data. Check the encoded input and the selected decoding scope.
No. URL encoding is a reversible way to represent characters. It does not protect passwords, personal information, or other sensitive data.
Yes. Select Encode and URL Component, then enter the parameter value. This is useful when a value contains spaces, ampersands, equals signs, or other special characters.
No. The converter processes your input locally in your browser and does not require an external processing API or an account.
Yes. The tool is free to use on desktop and mobile browsers, with instant conversion and no registration required.
URLs are essential to how websites, browsers, and web applications communicate. They identify web resources, carry query parameters, and connect users to specific pages.
However, URLs can contain characters that have special meanings. Spaces, ampersands, question marks, Unicode characters, and other symbols may need to be encoded to work correctly in a particular part of a URL.
A URL encoder converts characters into an appropriate encoded representation. A URL decoder reverses valid encoded sequences into readable text.
Nimzoa's free URL Encoder & Decoder makes these conversions easier. You can encode or decode text directly in your browser, choose between URL Component and Full URL modes, and copy the result without installing software.
This guide explains how URL encoding works, how to decode a URL online, the differences between JavaScript encoding functions, and how to avoid common mistakes.
URL encoding is a method of representing characters within URLs so they can be interpreted correctly.
It is commonly called percent encoding because encoded bytes are written using a percent sign followed by two hexadecimal digits.
For example:
Original character | Percent-encoded representation |
|---|---|
Space | %20 |
& | %26 |
= | %3D |
? | %3F |
# | %23 |
/ | %2F |
+ | %2B |
@ | %40 |
Whether a character needs encoding depends on where it appears in the URL.
A slash, for example, is meaningful as a path separator. An ampersand commonly separates query parameters. If these characters are intended to be part of an individual parameter value rather than separators, encoding them can prevent incorrect interpretation.
Suppose you want to pass this search phrase as a query-parameter value:
red shoes & bags
When encoded as a URL component, it becomes:
red%20shoes%20%26%20bags
This representation allows the ampersand to be treated as part of the search phrase instead of as a separator between query parameters.
The resulting URL could look like:
https://example.com/search?q=red%20shoes%20%26%20bags
The q parameter contains the intended search phrase.
URL decoding reverses valid percent-encoded representations into readable characters.
For example:
hello%20world
decodes to:
hello world
Similarly:
red%20shoes%20%26%20bags
decodes to:
red shoes & bags
URL decoding is useful when reading encoded links, examining API requests, debugging query parameters, or interpreting data copied from browser address bars.
Encoded text | Decoded text |
|---|---|
hello%20world | hello world |
name%3DJohn | name=John |
a%26b | a&b |
hello%3F | hello? |
email%40example.com | |
%E2%9C%93 | ✓ |
These examples assume component-style decoding, where encoded reserved characters are converted to their literal characters.
Full URL decoding can behave differently because some reserved characters must retain their structural meaning.
Nimzoa provides a browser-based way to convert encoded text into readable characters.
Choose the Decode option in the converter.
Select URL Component for an individual encoded value or Full URL for a complete URL whose structure should be preserved.
Type or paste the text containing percent-encoded sequences.
For example:
https%3A%2F%2Fexample.com%2Fproducts%3Fid%3D25
In URL Component mode, this example decodes to:
https://example.com/products?id=25
Use Copy Output to save the converted result to your clipboard.
The conversion is performed locally in your browser.
Encoding is useful when text contains characters that may be interpreted as URL syntax.
Choose the Encode option.
Use URL Component when encoding an individual value, such as a search phrase.
Use Full URL when encoding a complete URL while preserving many of its structural separators.
For example:
summer sale & offers
In URL Component mode, the result is:
summer%20sale%20%26%20offers
Copy the encoded value and place it in the appropriate URL component.
Remember that encoding a complete URL and encoding a query-parameter value are different operations.
An encoder and decoder perform opposite transformations.
Feature | URL Encoder | URL Decoder |
|---|---|---|
Main purpose | Convert text into an encoded representation | Convert valid encoded text into readable characters |
Typical input | hello world | hello%20world |
Typical output | hello%20world | hello world |
Common use | Preparing parameter values | Inspecting encoded data |
Special characters | May be percent-encoded | Valid percent sequences may be decoded |
Both operations are useful when building or troubleshooting websites, APIs, and links.
Nimzoa combines them in one tool so you do not need separate websites for everyday conversions.
This is one of the most important distinctions in URL encoding.
A complete URL contains structural characters with special purposes.
Consider:
https://example.com/search?q=red shoes&sort=popular
The colon, slashes, question mark, equals signs, and ampersand are meaningful parts of the URL.
Encoding the entire string as one component would encode many of those structural characters.
That may be appropriate when embedding the whole URL as a value inside another URL, but it is usually not what you want when preserving the structure of the original URL.
JavaScript's encodeURIComponent() is designed to encode a URI component.
For example:
encodeURIComponent("red shoes & bags");Result:
red%20shoes%20%26%20bagsThe ampersand is encoded because it belongs to the value, not to the query string's structure.
JavaScript's encodeURI() preserves many reserved characters that can be meaningful in a complete URI.
For example:
encodeURI("https://example.com/search?q=red shoes&sort=popular");Result:
https://example.com/search?q=red%20shoes&sort=popularThe URL's structural separators remain present.
Input | URL Component mode | Full URL mode |
|---|---|---|
hello world | hello%20world | hello%20world |
a&b=c | a%26b%3Dc | a&b=c |
https://example.com/a b | https%3A%2F%2Fexample.com%2Fa%20b | https://example.com/a%20b |
Important: Full URL mode does not understand whether every separator is correctly placed. It applies encoding rules; it is not a complete URL validation or repair tool.
JavaScript also provides two commonly used decoding functions.
decodeURIComponent() decodes percent-encoded sequences in an individual component, including encoded reserved characters.
decodeURI() is designed for complete URIs and preserves certain percent-encoded reserved characters.
For example:
decodeURIComponent("red%20shoes%20%26%20bags");Result:
red shoes & bagsBut:
decodeURI("red%20shoes%20%26%20bags");Result:
red shoes %26 bagsThe second function preserves %26 because it represents an ampersand, a character with a reserved meaning in URI syntax.
This distinction matters when debugging encoded links.
If you expect %26 to become &, choose component decoding rather than full URI decoding.
Percent encoding is the underlying representation used for many characters in URLs.
An encoded byte is written as a percent sign followed by two hexadecimal digits.
For example, %20 represents the byte value hexadecimal 20, which corresponds to a space in UTF-8 and ASCII.
For non-ASCII characters, UTF-8 commonly represents a character using multiple bytes, and each byte may be percent-encoded.
For example, the check mark ✓ is represented in UTF-8 by three bytes.
Its percent-encoded form is:
%E2%9C%93
When decoded correctly as UTF-8, those bytes become the original check mark.
Percent encoding is not limited to English-language characters.
Modern web applications often process text containing accents, non-Latin scripts, and emoji.
For example:
encodeURIComponent("café");Result:
caf%C3%A9The accented character is represented using UTF-8 bytes.
An emoji example:
encodeURIComponent("😊");Result:
%F0%9F%98%8AThese encoded values can be decoded back into their original characters when the encoded sequence is valid.
Unicode handling is especially important for international websites, multilingual search forms, and API integrations.
Spaces are one of the most confusing aspects of URL encoding.
With JavaScript's encodeURIComponent() function:
encodeURIComponent("hello world");The result is:
hello%20worldHowever, HTML form-style query serialization commonly uses + for spaces.
For example, JavaScript's URLSearchParams can produce:
new URLSearchParams({ q: "hello world" }).toString();Result:
q=hello+worldBoth conventions appear in real web applications, but they are not interchangeable in every context.
In particular, decodeURIComponent() does not automatically convert a literal plus sign into a space.
decodeURIComponent("hello+world");Result:
hello+worldIf you are decoding form-encoded query data, use an appropriate form-data or URL query parser.
Do not assume every + character in a URL should become a space.
Query parameters allow websites to pass information through a URL.
For example:
https://example.com/search?q=shoes
The parameter name is q, and its value is shoes.
Now suppose the value is:
shoes & accessories
If you insert that value directly into the URL, the ampersand could be interpreted as a new query-parameter separator.
Using component encoding:
const value = "shoes & accessories"; const encoded = encodeURIComponent(value);Result:
shoes%20%26%20accessoriesYou can then construct:
https://example.com/search?q=shoes%20%26%20accessories
For application code, using the browser's URL and URLSearchParams APIs is often safer than manually concatenating complex query strings.
Example:
const url = new URL("https://example.com/search"); url.searchParams.set("q", "shoes & accessories"); console.log(url.toString());Result:
https://example.com/search?q=shoes+%26+accessoriesNotice that URLSearchParams uses form-style serialization, so spaces become plus signs.
Both examples can represent the intended query value when interpreted using the appropriate conventions.
APIs frequently use URLs to identify resources and pass request parameters.
For example, an API request might contain a search value, category name, identifier, or filter.
If a parameter contains characters such as & or =, component encoding can prevent those characters from being mistaken for query syntax.
Consider this value:
status=active&sort=latest
As a single component, it becomes:
status%3Dactive%26sort%3Dlatest
This preserves the value as data rather than allowing it to be interpreted as two separate parameters.
When writing application code, prefer established URL construction APIs and follow the API provider's documentation.
Marketing URLs frequently contain campaign-tracking parameters.
For example, a campaign link might include:
utm_source=newsletter
utm_medium=email
utm_campaign=summer sale
The campaign name contains a space and should be serialized appropriately.
An encoded representation might be:
utm_campaign=summer%20sale
Proper encoding helps preserve parameter values when links are copied, shared, or processed.
However, URL encoding does not guarantee accurate analytics attribution.
Tracking also depends on correct parameter names, consistent campaign conventions, analytics configuration, and functioning destination pages.
For campaign link creation, a dedicated UTM Builder can help organize tracking parameters before the URL is shared.
No. URL encoding and encryption solve different problems.
URL encoding represents characters in a form suitable for a particular URL context.
Encryption protects information using cryptographic methods and keys.
For example:
secret message
can be encoded as:
secret%20message
Anyone can reverse this transformation.
The encoded text is not secret or protected.
Do not place passwords, access tokens, personal data, or other sensitive information in URLs merely because they are percent encoded.
URLs may appear in browser history, application logs, analytics systems, referrer information, or shared messages.
Use appropriate security practices and data-handling methods instead.
URL decoding may fail when the input contains malformed percent-encoded sequences or invalid UTF-8 data.
For example:
hello%2
This contains an incomplete percent sequence.
A valid percent-encoded byte requires two hexadecimal digits after the percent sign.
For example:
hello%ZZ
The characters ZZ are not hexadecimal digits.
Even if percent sequences are structurally correct, the decoded bytes may not form valid UTF-8 text.
For example, a lone %E9 byte is not a complete UTF-8 encoding of é.
Double encoding occurs when text that is already encoded is encoded again.
For example:
Original text:
hello world
Encoded once:
hello%20world
Encoded twice:
hello%2520world
The percent sign itself becomes %25.
Decoding the double-encoded value once produces:
hello%20world
Decoding it again produces:
hello world
Repeated decoding should not be performed automatically on untrusted input, especially when different application layers interpret encoded characters differently.
Full URL decoding preserves certain encoded reserved characters.
Component decoding converts them.
If %26 remains encoded when you expected an ampersand, check whether you selected Full URL instead of URL Component.
Encoding a complete URL with component rules converts structural separators such as : and /.
This may be correct when embedding the URL as data, but not when preserving the original URL's structure.
Characters such as &, =, and ? may be part of a value or part of URL syntax.
Choose the appropriate encoding method based on their role.
Encoding converts characters; it does not confirm that the destination exists, the URL is safe, or the syntax is appropriate for every use case.
Percent encoding is reversible and provides no confidentiality.
Form-style query serialization may use + for spaces, but ordinary component decoding does not automatically interpret every plus sign that way.
Double encoding can produce unexpected values such as %2520.
Check whether the input has already been encoded before applying another transformation.
Applications should handle malformed input safely and avoid treating decoded text as trusted instructions, HTML, file paths, or executable content.
Here are several practical examples using JavaScript.
Output:
free%20online%20toolsOutput:
free online toolsOutput:
hello%40example.comOutput:
cats & dogsOutput:
https://example.com/my%20page?q=hello%20worldThese examples demonstrate standard JavaScript encoding behavior.
They are not a substitute for validating application input or constructing URLs safely in production code.
URL encoding and decoding are useful in many everyday workflows.
Web developers use them when preparing query parameters, debugging requests, and integrating APIs.
SEO professionals use them to inspect encoded links, troubleshoot URL parameters, and understand how search engines and browsers handle different characters.
Digital marketers use encoded URLs in campaign tracking, email links, and advertising destinations.
Website administrators may need to inspect redirect destinations, query strings, and content management system URLs.
Students and beginners can use a URL encoder to learn how percent encoding works.
Everyday internet users may need to decode a link to understand what its encoded text represents.
Nimzoa offers a practical browser-based workspace for common URL encoding tasks.
The tool supports both encoding and decoding, with separate options for URL Component and Full URL processing.
You can type or paste text, inspect the converted result immediately, swap input and output, and copy the output when ready.
Its built-in query-parameter example demonstrates how encoded values are used in real URLs.
The conversion happens in your browser, without requiring an account or an external processing API.
The tool is designed for quick conversions rather than bulk processing, encryption, shortened-link expansion, or automatic URL validation.
%20 Represents a space character using percent encoding.
%26 Represents an ampersand (&) when decoded as a URL component.
Nimzoa's URL Encoder & Decoder is free to use, with no account required.
Yes. Unicode characters, including emoji, can be represented using percent-encoded UTF-8 bytes.
No. URL decoding reverses percent encoding. It does not decrypt protected information.
%25 represents a literal percent sign. It may also appear when already encoded text is encoded again.
Use encodeURIComponent() for an individual URL component or parameter value. Use encodeURI() when applying URI encoding rules while preserving many structural characters in a complete URI.
A literal + is not automatically converted to a space by decodeURIComponent(). The plus-as-space convention belongs to form-style query encoding.
Whether you're preparing a query parameter, inspecting a percent-encoded link, or troubleshooting special characters, choosing the correct encoding scope is essential.
Use Nimzoa's free URL Encoder & Decoder above to convert text instantly, review the result, and copy the output for your next task.
Remember: URL encoding is a character-representation method, not encryption or URL validation.