URL Encoder/Decoder: Guida Completa alla Codifica URL

Cos'è la Codifica URL e Perché È Necessaria

La codifica URL (URL encoding o percent-encoding) è un meccanismo fondamentale del web che permette di trasmettere caratteri speciali all'interno degli indirizzi web. Quando inserisci una query di ricerca su Google, invii dati tramite form o costruisci API REST, i caratteri speciali vengono automaticamente convertiti in sequenze sicure che possono viaggiare attraverso internet senza causare problemi di parsing o interpretazione errata.

Il nostro URL Encoder/Decoder è uno strumento completamente gratuito che funziona al 100% nel tuo browser, senza inviare alcun dato a server esterni. È perfetto per sviluppatori, SEO specialist, system administrator e chiunque lavori quotidianamente con URL, parametri web e API RESTful.

Come Funziona il Percent-Encoding (RFC 3986)

Gli URL (Uniform Resource Locator) possono contenere solo un set limitato di caratteri ASCII. Secondo la specifica RFC 3986, i caratteri permessi negli URL sono suddivisi in:

• Caratteri non riservati: A-Z, a-z, 0-9, - _ . ~ (sempre sicuri)
• Caratteri riservati: : / ? # [ ] @ ! $ & ' ( ) * + , ; = (hanno significato speciale)

Tutti gli altri caratteri (spazi, lettere accentate, emoji, simboli) devono essere codificati per essere trasmessi correttamente attraverso il protocollo HTTP.

Il Processo di Conversione

Il percent-encoding converte ogni carattere non sicuro nel suo valore esadecimale UTF-8, preceduto dal simbolo %:

Carattere → Byte UTF-8 → Percent-Encoded

Spazio    → 0x20      → %20
è         → 0xC3 0xA8 → %C3%A8
à         → 0xC3 0xA0 → %C3%A0
€         → 0xE2 0x82 0xAC → %E2%82%AC
😀        → 0xF0 0x9F 0x98 0x80 → %F0%9F%98%80

Tabella dei Caratteri Più Comuni

Carattere	Codifica URL	Descrizione	Uso Tipico
Spazio	%20 o +	Spazio bianco	Query string
!	%21	Punto esclamativo	Testi, messaggi
#	%23	Hash/Cancelletto	Fragment identifier
$	%24	Dollaro	Prezzi, valute
%	%25	Percentuale	Percentuali, escape
&	%26	Ampersand	Separatore parametri
'	%27	Apostrofo	Testi italiani
+	%2B	Più	Operazioni matematiche
,	%2C	Virgola	Liste, separatori
/	%2F	Slash	Path URL
:	%3A	Due punti	Porte, protocolli
=	%3D	Uguale	Assegnazione parametri
?	%3F	Punto interrogativo	Inizio query string
@	%40	Chiocciola	Email, credenziali
è	%C3%A8	e accentata	Italiano
ñ	%C3%B1	eñe	Spagnolo

7+ Casi d'Uso Reali con Esempi

1. Query String nei Motori di Ricerca

Quando cerchi "caffè italiano migliore" su Google, l'URL diventa:

https://www.google.com/search?q=caff%C3%A8%20italiano%20migliore

Senza codifica, il server non saprebbe interpretare correttamente la lettera accentata "è".

2. Parametri API REST

Le API moderne spesso richiedono parametri codificati per filtri complessi:

GET /api/users?filter=nome%3DMario%26citt%C3%A0%3DRoma%26et%C3%A0%3E30

// Decodificato: filter=nome=Mario&città=Roma&età>30

3. Link di Condivisione Social

I link di condivisione includono URL e testo codificati:

https://twitter.com/intent/tweet?url=https%3A%2F%2Fthejord.it%2Ftools&text=Ottimi%20tool%20per%20sviluppatori%21

// Decodificato: url=https://thejord.it/tools&text=Ottimi tool per sviluppatori!

4. OAuth Redirect URI

I sistemi di autenticazione OAuth 2.0 usano redirect_uri codificati:

https://accounts.google.com/oauth2/auth
  ?client_id=xyz
  &redirect_uri=https%3A%2F%2Fmyapp.com%2Fauth%2Fcallback
  &scope=email%20profile
  &response_type=code

5. Form Data (application/x-www-form-urlencoded)

I form HTML inviano dati con codifica URL per default:

POST /contact HTTP/1.1
Content-Type: application/x-www-form-urlencoded

nome=Mario+Rossi&email=mario%40example.com&messaggio=Ciao%2C+vorrei+informazioni%21

6. Cookie Values

I valori dei cookie contenenti JSON devono essere codificati:

Set-Cookie: user_prefs=%7B%22theme%22%3A%22dark%22%2C%22lang%22%3A%22it%22%7D

// Decodificato: {"theme":"dark","lang":"it"}

7. Deep Links per App Mobile

I deep link per iOS/Android usano URL encoding per parametri:

myapp://product/view?name=Caff%C3%A8%20Espresso&price=2.50&category=bevande%20calde

8. Webhook Payload URLs

I webhook (Slack, Discord, etc.) richiedono URL codificati nei payload:

https://hooks.slack.com/services/xxx/yyy?text=Deploy%20completato%20%E2%9C%85%20su%20produzione

Esempi di Codice in 5+ Linguaggi

JavaScript (Browser e Node.js)

// encodeURIComponent - per valori di parametri (RACCOMANDATO)
const encoded = encodeURIComponent('caffè italiano €5');
console.log(encoded); // caff%C3%A8%20italiano%20%E2%82%AC5

// decodeURIComponent - per decodificare
const decoded = decodeURIComponent(encoded);
console.log(decoded); // caffè italiano €5

// encodeURI - per URL completi (NON codifica : / ? # etc)
const url = encodeURI('https://example.com/path?q=caffè espresso');
console.log(url); // https://example.com/path?q=caff%C3%A8%20espresso

// URLSearchParams - per costruire query string (MODERNO)
const params = new URLSearchParams({
  nome: 'Mario Rossi',
  città: 'Roma',
  email: 'mario@example.com'
});
console.log(params.toString());
// nome=Mario+Rossi&citt%C3%A0=Roma&email=mario%40example.com

// URL API - per manipolare URL completi
const myUrl = new URL('https://api.example.com/search');
myUrl.searchParams.set('query', 'caffè italiano');
myUrl.searchParams.set('limit', '10');
console.log(myUrl.href);
// https://api.example.com/search?query=caff%C3%A8+italiano&limit=10

Python

from urllib.parse import quote, unquote, urlencode, parse_qs

# quote - codifica singola stringa
encoded = quote('caffè italiano €5')
print(encoded)  # caff%C3%A8%20italiano%20%E2%82%AC5

# quote con safe chars personalizzati
encoded_safe = quote('path/to/file', safe='/')
print(encoded_safe)  # path/to/file (slash non codificato)

# unquote - decodifica
decoded = unquote(encoded)
print(decoded)  # caffè italiano €5

# urlencode - per dizionari (query string)
params = urlencode({
    'nome': 'Mario Rossi',
    'città': 'Roma',
    'prezzo': '€5.00'
})
print(params)  # nome=Mario+Rossi&citt%C3%A0=Roma&prezzo=%E2%82%AC5.00

# parse_qs - parsing query string
parsed = parse_qs('nome=Mario&città=Roma')
print(parsed)  # {'nome': ['Mario'], 'città': ['Roma']}

PHP

<?php
// urlencode - codifica (spazi come +)
$encoded = urlencode('caffè italiano €5');
echo $encoded; // caff%C3%A8+italiano+%E2%82%AC5

// rawurlencode - codifica RFC 3986 (spazi come %20)
$encoded_raw = rawurlencode('caffè italiano');
echo $encoded_raw; // caff%C3%A8%20italiano

// urldecode / rawurldecode - decodifica
$decoded = urldecode($encoded);
echo $decoded; // caffè italiano €5

// http_build_query - per array associativi
$params = http_build_query([
    'nome' => 'Mario Rossi',
    'città' => 'Roma',
    'tags' => ['php', 'web', 'api']
]);
echo $params;
// nome=Mario+Rossi&citt%C3%A0=Roma&tags%5B0%5D=php&tags%5B1%5D=web&tags%5B2%5D=api

// parse_str - parsing query string
parse_str('nome=Mario&città=Roma', $result);
print_r($result); // Array ( [nome] => Mario [città] => Roma )
?>

Java

import java.net.URLEncoder;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;

// Codifica
String encoded = URLEncoder.encode("caffè italiano €5", StandardCharsets.UTF_8);
System.out.println(encoded); // caff%C3%A8+italiano+%E2%82%AC5

// Decodifica
String decoded = URLDecoder.decode(encoded, StandardCharsets.UTF_8);
System.out.println(decoded); // caffè italiano €5

// Con Java 11+ HttpClient
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;

String query = URLEncoder.encode("caffè", StandardCharsets.UTF_8);
URI uri = URI.create("https://api.example.com/search?q=" + query);
HttpRequest request = HttpRequest.newBuilder(uri).GET().build();

C# / .NET

using System;
using System.Web;
using System.Net;

// HttpUtility.UrlEncode (System.Web)
string encoded = HttpUtility.UrlEncode("caffè italiano €5");
Console.WriteLine(encoded); // caff%c3%a8+italiano+%e2%82%ac5

// Uri.EscapeDataString (RFC 3986 compliant)
string encoded2 = Uri.EscapeDataString("caffè italiano");
Console.WriteLine(encoded2); // caff%C3%A8%20italiano

// WebUtility.UrlEncode (.NET Core)
string encoded3 = WebUtility.UrlEncode("caffè italiano");
Console.WriteLine(encoded3); // caff%C3%A8+italiano

// Decodifica
string decoded = HttpUtility.UrlDecode(encoded);
Console.WriteLine(decoded); // caffè italiano €5

// QueryString builder
var query = HttpUtility.ParseQueryString(string.Empty);
query["nome"] = "Mario Rossi";
query["città"] = "Roma";
Console.WriteLine(query.ToString()); // nome=Mario+Rossi&citt%c3%a0=Roma

Go

package main

import (
    "fmt"
    "net/url"
)

func main() {
    // QueryEscape - codifica
    encoded := url.QueryEscape("caffè italiano €5")
    fmt.Println(encoded) // caff%C3%A8+italiano+%E2%82%AC5

    // QueryUnescape - decodifica
    decoded, _ := url.QueryUnescape(encoded)
    fmt.Println(decoded) // caffè italiano €5

    // url.Values - costruire query string
    params := url.Values{}
    params.Add("nome", "Mario Rossi")
    params.Add("città", "Roma")
    fmt.Println(params.Encode()) // citt%C3%A0=Roma&nome=Mario+Rossi
}

Confronto: URL Encoding vs Altre Codifiche

Caratteristica	URL Encoding	Base64	HTML Entities	JSON Escape
Scopo principale	URL sicuri	Dati binari → testo	Caratteri HTML	Stringhe JSON
Formato output	%XX	A-Za-z0-9+/=	&nome; o {	\uXXXX
Overhead medio	~3x per speciali	~1.33x sempre	~6x per speciali	~6x per speciali
Preserva leggibilità	Parziale	No	Sì	Parziale
Standard	RFC 3986	RFC 4648	HTML5	RFC 8259
Uso con binari	No	Sì	No	No
Caso d'uso tipico	Query string	Immagini inline	Pagine web	API response

FAQ - Domande Frequenti

Qual è la differenza tra encodeURI e encodeURIComponent in JavaScript?

encodeURI() codifica un URL completo, lasciando intatti i caratteri strutturali come :, /, ?, #, &. È utile quando hai un URL completo con caratteri speciali solo nel path o query. encodeURIComponent() codifica tutto tranne lettere, numeri e - _ . ~. Usa encodeURIComponent() per i valori dei parametri, encodeURI() per URL completi già formati.

Perché lo spazio diventa %20 oppure + ?

Secondo RFC 3986 (URI Generic Syntax), lo spazio deve diventare %20. Tuttavia, nel formato application/x-www-form-urlencoded (usato dai form HTML e definito in HTML5), lo spazio diventa + per compatibilità storica. Entrambi sono validi ma in contesti diversi. Per sicurezza, usa sempre %20 negli URL e accetta entrambi in decodifica.

Come gestisco i caratteri Unicode (emoji, cinese, arabo)?

I caratteri Unicode vengono prima convertiti nella loro rappresentazione UTF-8 (1-4 byte), poi ogni byte viene percent-encoded. Un emoji come 😀 (U+1F600) diventa %F0%9F%98%80 perché in UTF-8 occupa 4 byte. Un carattere cinese come 中 (U+4E2D) diventa %E4%B8%AD (3 byte UTF-8).

La codifica URL fornisce sicurezza?

Assolutamente no. La codifica URL è completamente reversibile e serve esclusivamente a trasmettere caratteri speciali senza corrompere la struttura dell'URL. Non fornisce alcuna protezione dei dati. Per proteggere informazioni sensibili usa sempre HTTPS, crittografia end-to-end e mai includere password o token sensibili negli URL.

Devo codificare l'intero URL o solo i parametri?

Codifica solo i valori dei parametri, mai l'intera struttura dell'URL. La struttura (https://, /path/, ?, &, =) deve rimanere intatta per funzionare. Esempio corretto: ?name= + encodeURIComponent(value).

Come evito la doppia codifica (double encoding)?

La doppia codifica avviene quando codifichi testo già codificato: %20 diventa %2520. Per evitarla: 1) Decodifica sempre prima di ri-codificare, 2) Verifica se il testo contiene pattern %XX prima di codificare, 3) Usa funzioni che gestiscono questo caso automaticamente. La doppia codifica può anche indicare un tentativo di attacco.

Qual è la lunghezza massima di un URL?

Non esiste un limite ufficiale nelle specifiche, ma nella pratica: Internet Explorer supporta fino a 2083 caratteri, Chrome/Firefox/Safari circa 65.000 caratteri, ma molti server hanno limiti inferiori (8KB tipico per Apache/Nginx). Per dati grandi, usa POST invece di GET.

Come testo se il mio URL è codificato correttamente?

Usa il nostro URL Encoder/Decoder per verificare. Incolla l'URL, decodificalo e controlla se il risultato è il testo originale. Un URL ben formato deve: 1) Non contenere spazi (solo %20 o +), 2) Non contenere caratteri non-ASCII visibili, 3) Decodificarsi senza errori.

Best Practice per la Sicurezza

✅ Cosa Fare

• Codifica sempre l'input utente prima di inserirlo in URL per prevenire injection
• Usa le librerie standard del tuo linguaggio - evita implementazioni custom
• Valida gli URL dopo la decodifica per prevenire attacchi path traversal
• Usa HTTPS per proteggere i dati in transito (gli URL sono visibili nei log)
• Limita la lunghezza degli URL accettati per prevenire DoS
• Sanitizza i path decodificati prima di accedere al filesystem

❌ Cosa NON Fare

• Non fidarti mai di URL decodificati senza validazione - possono contenere payload malevoli
• Non costruire URL concatenando stringhe senza codificare i valori
• Non assumere che la codifica prevenga XSS o SQL injection - serve solo per il trasporto
• Non inserire mai password, token o dati sensibili negli URL - sono loggati ovunque
• Non ignorare la doppia codifica - può indicare un tentativo di bypass

Esempio di Codice Sicuro

// ❌ PERICOLOSO - URL injection possibile
const url = `https://api.com/user?id=${userId}&name=${userName}`;

// ✅ SICURO - sempre codificare i valori utente
const url = `https://api.com/user?id=${encodeURIComponent(userId)}&name=${encodeURIComponent(userName)}`;

// ✅ ANCORA MEGLIO - validare prima, poi codificare
function buildUserUrl(userId, userName) {
  // Validazione
  if (!/^[a-zA-Z0-9_-]+$/.test(userId)) {
    throw new Error('Invalid userId');
  }
  if (userName.length > 100) {
    throw new Error('userName too long');
  }

  // Costruzione sicura
  const params = new URLSearchParams({ id: userId, name: userName });
  return `https://api.com/user?${params}`;
}

Tool Correlati su THEJORD

Scopri altri strumenti utili per sviluppatori e professionisti del web:

• Base64 Encoder/Decoder - Codifica e decodifica dati binari in formato ASCII sicuro
• JSON Formatter - Formatta, valida e minimizza dati JSON con syntax highlighting
• Hash Generator - Genera hash MD5, SHA-1, SHA-256, SHA-512 per verifica integrità
• RegEx Tester - Testa e debugga espressioni regolari in tempo reale
• Diff Checker - Confronta due testi e trova le differenze

Risorse Esterne Autorevoli

• RFC 3986 - URI Generic Syntax - Specifica ufficiale IETF
• MDN - encodeURIComponent() - Documentazione JavaScript
• Wikipedia - Percent-encoding - Panoramica generale

🔗 Prova il nostro URL Encoder/Decoder gratuito →