{{ decodedIsUrl ? 'Normalized URL' : 'Decoded Text' }}
{{ mainOutput }}
Characters: {{ charCount }} Parameters: {{ paramCount }} {{ payloadSummary }} Text only
Trackers removed: {{ trackersRemoved }} Duplicates removed: {{ duplicatesPruned }} Empty removed: {{ emptiesRemoved }} Filtered: {{ allowBlockRemoved }}
Depth: {{ decode_depth }} “+” → space IDN→Unicode Strip trackers No fragment Trim slash Lower host Remove www. Sort params {{ unicode_normalization }} No auth No :80/:443 Collapse // De-dup ({{ dedupe_params_mode.replace('keep-','') }}) No empty params Allow list Block list Scheme: {{ force_scheme }}
Key Value Copy
{{ p.key }} {{ p.value }}
No query parameters
# Char Code point UTF-8 ASCII Unreserved Reserved Copy
{{ r.idx }} {{ r.charDisplay }} {{ r.u }} {{ r.utf8 }} {{ r.isASCII ? 'Yes' : 'No' }} {{ r.isUnreserved ? 'Yes' : 'No' }} {{ r.isReserved ? 'Yes' : 'No' }}
{{ payloadSummary }}

                


                

                    

                        
                    

                    

                        
                    

                


                

                    

                        

                            

                                
                                
                            

                        

                    


                    

                

            


        

    

                

                

                    

                        

                            Tags:
                                                            
                                    Devtools
                                
                                ,                                                             
                                    Encoding
                                
                                                                                    

                        

                            Export to PDF
                            Fullscreen
                        

                    

                

            

        

    


        
    

        

        

            


                

                    

                    
                


                

                

                
            

            

                
                
            

        

    


    

        

                                                                                                                                                                                                                                                                        
        

            

                
                
                
                
            

            

                
                
            

            

                

                    

                        

                            
                            
                        

                    

                    

                        

                            
                            
                        

                    

                    

                        

                            
                            
                        

                    

                    

                        

                            
                            
                        

                    

                    

                        
                        
                    

                    

                        
                        

                            
                            
                        

                    

                    

                        
                        

                            
                            
                        

                    

                    

                        
                        

                            
                            :
                            
                        

                    

                    

                        
                        

                            
                            
                        

                    

                    

                        
                        
                    

                    

                        
                        
                    

                    

                        

                            
                            
                        

                    

                    

                        
                        
                    

                    

                        
                        
                    

                

            


            
        

    



    

        

  

  
Uniform Resource Locators are structured web addresses that may include percent escapes, query strings, and fragments, so reading them can be confusing when text is encoded or repeated. A web address decoder and cleaner turns dense links into clear text you can verify and share.


  
Paste any text or a full link and you get a decoded address when one is present and a readable string otherwise. You can remove common tracking parameters and tidy the host and path to match how people write links and avoid clutter, with the summary calling out how many trackers, duplicates, empty values, or blocked keys were removed.


  
Character inspection highlights each symbol so mixed encodings or copied artifacts stand out quickly. If the text hides structured data or an encoded blob you get a short preview for a quick look.


  
A compact summary shows which cleanup choices were applied, so runs remain comparable across cases. Treat results as a convenience and still check unknown links before opening them.






  
Technical Details:


  
Uniform Resource Locator (URL) decoding converts percent escapes to characters, identifies scheme, host, path, query, and fragment, and returns a normalized display string for inspection. When the text is not a URL, the decoded string is still analyzed to aid review.


  
Character analysis reports per‑symbol properties: the Unicode code point, its UTF‑8 bytes as uppercase hexadecimal pairs, ASCII membership, and two flags indicating whether the character falls into the unreserved or reserved groups used by URL syntax.


  
The engine also checks the fully decoded string for two payload types: JavaScript Object Notation (JSON) and Base64‑encoded text. When detected, it renders a short preview and a summary with either line count or character count.


  
When the decoded text parses as a URL, optional normalizations can improve readability without altering meaning: host casing and www removal, path cleanup, fragment removal, and structured query operations including tracker removal, allow and block rules, duplicate handling, empty-value pruning, and sort order. Internationalized Domain Names (IDN) can be displayed in Unicode for the hostname only, and the tool counts how many parameters each sanitizer removed so changes are auditable.


  
Processing pipeline

  
    
    
  1. Take input text; if blank, clear outputs.
    2. 
    
  2. Decode percent escapes once; repeat up to the chosen depth or until stable.
    3. 
    
  3. Optionally treat plus signs as spaces before each decode pass.
    4. 
    
  4. Optionally apply Unicode normalization using NFC or NFKC.
    5. 
    
  5. Attempt URL parse; accept scheme‑less inputs by assuming http:// for parsing only.
    6. 
    
  6. If not a URL, produce character analysis and payload preview.
    7. 
    
  7. If a URL, apply selected normalizations to scheme, authority, path, query, and fragment.
    8. 
    
  8. Rebuild the query string in stable order and construct the display form.
    9. 
    
  9. Populate parameters, character table, payload preview, QR code, and JSON summary.
    10. 
  


  
Symbols & units

  

    

      
      
        

          Symbol
          Meaning
          Unit/Datatype
          Source
        

      
      
        

          d
          Decode depth (max passes)
          integer (1–12)
          Input
        

        

          N
          Unicode normalization form
          enum {NFC, NFKC, none}
          Input
        

        

          cp
          Unicode code point
          integer U+0000…
          Derived
        

        

          u
          Parsed URL instance
          object
          Derived
        

        

          Q
          Ordered query pairs
          list of [key, value]
          Derived
        

      
    

  


  
Worked example

  

    
Input: https://www.Example.com:80//path/%7Eme/?utm_source=newsletter&id=42&id=9&ref=abc&empty=&q=a+b#top

    
Settings: depth 2; plus→space; Unicode NFC; show IDN in Unicode; remove default port; collapse slashes; trim trailing slash; remove fragment; lower‑case host; remove www; strip common trackers; de‑duplicate parameters (keep last); remove empty parameters; sort parameters.

    
Result: https://example.com/path/~me?id=9&q=a%20b

    
Interpretation: The link is safe to share without trackers, duplicates, or redundant formatting, and its path and host are canonicalized for readability.

  


  
Validation & bounds extracted from code

  

    

      
      
        

          Field
          Type
          Min
          Max
          Step/Pattern
          Error Text
          Placeholder
        

      
      
        

          Text or URL
          text
          —
          —
          —
          —
          https://example.com/?q=%2Bplus or example.com/%7Eme
        

        

          Decode depth
          number
          1
          12
          step 1
          —
          —
        

        

          Treat “+” as space
          checkbox
          —
          —
          —
          —
          —
        

        

          Unicode normalization
          select
          —
          —
          NFC, NFKC, none
          —
          —
        

        

          Force scheme
          select
          —
          —
          (no change), http, https
          —
          —
        

        

          De‑duplicate params
          select
          —
          —
          (off), keep first, keep last
          —
          —
        

      
    

  


  
I/O formats & encoding

  

    

      
      
        

          Input
          Accepted Families
          Output
          Encoding/Precision
          Rounding
        

      
      
        

          Text
          Plain text, web address with or without scheme
          Decoded string, character table, payload preview
          UTF‑8; code points as U+XXXX; bytes as hex
          Exact
        

        

          URL
          http, https, scheme‑less with example.com/path
          Normalized display URL, parameters
          Re‑encoded with uppercase percent bytes
          Exact
        

        

          JSON/Base64
          Embedded in full string
          Preview and downloadable text
          Up to 100 000 characters in payload view
          Exact
        

      
    

  


  
Networking & storage behavior

  
    
    
  • All decoding, normalization, previews, and QR generation run in the browser.
    • 
    
  • No data is transmitted or stored server‑side; clipboard and downloads are user‑initiated.
    • 
    
  • Links open only for http and https schemes.
    • 
  


  
Performance & determinism

  
    
    
  • Character analysis and decoding are linear in input length; parameter sorting is O(n log n).
    • 
    
  • Identical inputs with the same options yield identical outputs.
    • 
  


  
Security considerations

  
    
    
  • Do not paste secrets into shareable transcripts.
    • 
    
  • Stripping userinfo hides visible credentials in the display string; avoid distributing such links.
    • 
    
  • Opening unknown links may be unsafe; inspect before visiting.
    • 
  


  
Assumptions & limitations

  
    
    
  • Scheme‑less parsing assumes http:// only for parsing; display scheme follows options.
    • 
    
  • Unicode normalization applies to the decoded string, not raw percent bytes.
    • 
    
  • Tracker removal targets a fixed key list and keys starting with utm_.
    • 
    
  • Duplicate handling keeps strictly first or last by key; case is matched case‑insensitively.
    • 
    
  • Empty‑value pruning removes keys with zero‑length values only.
    • 
    
  • Sorting orders by lowercase key then lowercase value.
    • 
    
  • Character tables show at most 2 000 rows.
    • 
    
  • Payload previews include at most 100 000 characters.
    • 
    
  • QR output is 300×300 pixels with level M error correction.
    • 
    
  • Heads‑up IDN conversion affects hostname display only; it does not change the parsed host value.
    • 
  


  
Edge cases & error sources

  
    
    
  • Malformed percent sequences are left partially decoded where safe.
    • 
    
  • Inputs without dots or slashes are treated as plain text.
    • 
    
  • Spaces may appear after decoding if plus‑as‑space is enabled.
    • 
    
  • Non‑printable characters in decoded Base64 payloads are suppressed from preview.
    • 
    
  • Clipboard or file downloads can be blocked by browser permissions.
    • 
    
  • Some characters may be reserved in one URL component but not another.
    • 
    
  • Trimming a trailing slash applies only when the path length is greater than one.
    • 
    
  • Default port removal triggers only for :80 on http and :443 on https.
    • 
    
  • Multiple slashes collapse only within the path, not the scheme or authority.
    • 
    
  • Query allow‑list runs before the block‑list; the block‑list cannot re‑add removed keys.
    • 
  


  
Privacy & compliance

  
Processing is browser‑based and no data is transmitted or stored server‑side.






  
How‑to Guide:


  
Web address decoding and cleanup from input to a tidy, shareable result.

  
    
    
  1. Paste Text or URL into the field.
    2. 
    
  2. Set Decode depth; use a value above 1 for nested encodings.
    3. 
    
  3. Enable Treat “+” as space if values use form‑style encoding.
    4. 
    
  4. Choose Unicode normalization when combining marks look inconsistent.
    5. 
    
  5. Turn on cleanup options for host, path, fragment, and query as needed.
    6. 
    
  6. Use the tabs to review parameters, characters, payload, QR, and JSON.
    7. 
    
  7. Copy the final string or download the summary when satisfied.
    8. 
  


  

    Example: paste example.com/%7Eme?q=a%2Bb&utm_source=x, set depth 2 and plus‑as‑space, enable tracker removal, and copy the result http://example.com/~me?q=a%20b.
  


  
    
    
  • Use a higher depth for links that look double‑encoded.
    • 
    
  • Sort parameters to stabilize diffs across runs.
    • 
    
  • Keep last when duplicate keys record the final user choice.
    • 
  


  

    
Pro tip: apply an allow‑list to keep only the keys that matter and discard the rest by default.

  






  
FAQ:


  

    Is my data stored?
    
No. All decoding and normalization run locally and nothing is sent to a server. Clipboard and downloads occur only when you choose to use them.

    Applies to text, links, previews, and QR output.
  


  

    How accurate is character labeling?
    
ASCII membership and code points are exact. Unreserved and reserved flags follow internal patterns used for URL syntax. Component‑specific rules can still differ.

    Interpret characters in the context of their URL part.
  


  

    What inputs are supported?
    
Plain text and links with or without a scheme. Inputs with a dot or slash are parsed as links when possible; others are treated as text for analysis.

    Scheme‑less parsing assumes http for detection only.
  


  

    Can I use it offline?
    
Yes. Once the page is available, decoding and previews continue to work because processing happens in the browser.

    Network access is not required for the core operations.
  


  

    How do I decode a nested link?
    
Increase decode depth above one. The text is decoded pass by pass until it stops changing or the depth limit is reached.

    Plus‑as‑space can help with form‑style values.
  


  

    What does “Unreserved” mean?
    
These characters are commonly left unencoded in URLs. The flag helps you spot where encoding is optional versus required for safe transport.

    Interpretation can vary by component.
  


  

    Does it cost anything or require a license?
    
No licensing terms are shown in this package. Usage terms depend on how your instance is deployed by its host.

    Check your environment’s policies if uncertain.
  


  

    Can it open links directly?
    
Yes for http and https only. Opening is disabled for other schemes so you can review the text safely first.

    Always verify unfamiliar targets before visiting.
  






  
Troubleshooting:


  
    
    
  • No output appears: ensure the field is not blank and contains text.
    • 
    
  • Looks like text, not a link: inputs without dots or slashes are analyzed as text.
    • 
    
  • Spaces appear unexpectedly: disable plus‑as‑space or reduce decode depth.
    • 
    
  • IDN did not change: enable the IDN‑to‑Unicode display option.
    • 
    
  • Clipboard fails: grant clipboard permission or copy manually from the summary box.
    • 
    
  • QR download missing: ensure downloads are allowed for the site.
    • 
    
  • JSON not detected: confirm the string is valid JSON without trailing characters.
    • 
    
  • Base64 rejected: check padding; lengths must be a multiple of four.
    • 
  


  





  
Advanced Tips:


  
    
    
  •  Use an allow‑list to preserve only keys you trust; block‑list then removes extras.
    • 
    
  •  Keep last on duplicates to reflect a final user choice captured by the link.
    • 
    
  •  Sort parameters to stabilize diffs in logs and reviews.
    • 
    
  •  Collapse slashes and trim trailing slashes to avoid duplicate paths.
    • 
    
  •  Remove default ports to produce a minimal, canonical authority.
    • 
    
  •  Normalize with NFC when accents or combining marks render inconsistently.
    • 
  


  
Glossary:

  

    
Uniform Resource Locator (URL)

    
Standard form for web addresses including scheme, host, and path.


    
Percent encoding

    
Encoding bytes as % followed by two hexadecimal digits.


    
Query string

    
Key‑value pairs after ? used to pass parameters.


    
Fragment

    
Section identifier after # not sent to the server.


    
Internationalized Domain Name (IDN)

    
Hostname using non‑ASCII characters with a Unicode display form.


    
Unicode normalization

    
Standard forms such as NFC and NFKC to unify equivalent sequences.