Encodeur, décodeur et éditeur de paramètres URL

Encodez une valeur de paramètre, lisez du texte encodé en pourcentage ou modifiez les paramètres d’une URL. Choisissez le format adapté à votre tâche, puis copiez ou téléchargez le résultat.

Composants URL et valeurs de formulaire

Utilisez Encoder ou Décoder pour un nom ou une valeur de paramètre. Encoder une URL entière de cette façon échappe aussi ses séparateurs : cela convient lorsque l’URL devient elle-même une valeur dans une autre URL. Choisissez Modifier les paramètres pour conserver la structure de l’adresse.

Le format composant suit la fonction JavaScript encodeURIComponent : les lettres, les chiffres et - _ . ! ~ * ' ( ) restent lisibles. Les valeurs de formulaire suivent les règles application/x-www-form-urlencoded : les lettres, les chiffres et * - . _ restent lisibles, et les espaces deviennent +. Un signe plus littéral devient %2B dans les deux formats.

Au décodage, le format composant conserve les + ; le format formulaire les transforme en espaces. Chaque action décode une seule fois : %252F devient %2F, pas /. Les échappements incorrects et les séquences d’octets UTF-8 invalides provoquent une erreur plutôt qu’un résultat partiel. L’outil traite du texte UTF-8, pas des données binaires ni d’anciens encodages de caractères.

Modifier les paramètres sans perdre les noms répétés

Choisissez URL HTTP ou HTTPS complète pour une adresse entière, ou Paramètres seuls pour une chaîne comme tag=css&tag=html&q=hello+world. Le ? initial est facultatif dans le second mode. Ce mode traite # comme une partie de la valeur ; utilisez une URL complète pour conserver un fragment distinct.

Sélectionnez Lire les paramètres, modifiez les noms et les valeurs décodés, puis ajoutez ou supprimez des lignes. Les noms répétés, leur ordre et les valeurs vides sont conservés. L’entrée originale reste visible pour comparaison. Modifier cette entrée ou son type efface les lignes et le résultat jusqu’à une nouvelle lecture. Une URL sans paramètres peut servir de point de départ.

Original: https://example.com/?tag=css&tag=html&q=hello%20world#results
Rebuilt:  https://example.com/?tag=css&tag=html&q=hello+world#results

La reconstruction utilise l’encodage de formulaire et peut modifier l’écriture de l’URL. Les segments & vides sont retirés, un nom seul comme flag devient flag=, un marqueur de requête vide est retiré et les échappements sont uniformisés. La normalisation du navigateur peut aussi mettre le nom d’hôte en minuscules, retirer un port par défaut ou résoudre des segments de chemin. Le fragment est conservé dans l’URL normalisée par le navigateur. Vérifiez le résultat : une URL signée ou une application dépendant des octets exacts des paramètres peut ne plus fonctionner après normalisation.

Une URL complète doit commencer par http:// ou https://, sans espaces littéraux, caractères de contrôle ni barres obliques inverses. Cet éditeur local n’est pas un vérificateur de liens : il n’ouvre, ne contacte et ne vérifie jamais la destination.

Limites et outils complémentaires

L’entrée est limitée à 65 536 unités de chaîne JavaScript et à 200 paramètres. Les noms et valeurs décodés, les séparateurs, l’URL de base et le fragment partagent cette même limite lors de la reconstruction. Certains caractères, dont de nombreux émojis, occupent deux unités. La sortie encodée peut être plus longue que l’entrée. Les caractères Unicode incomplets sont refusés. Les données restent en mémoire et sont effacées lorsque vous quittez la page ; les copies dans le presse-papiers et les fichiers téléchargés restent sous votre contrôle et peuvent contenir des secrets.

Utilisez l’encodeur et décodeur HTML pour les entités comme &. L’échappement HTML et l’encodage URL répondent à des besoins distincts. Pour préparer une requête HTTP à partir d’une URL ou d’un corps de formulaire vérifiés, ouvrez le générateur de commandes cURL. Les valeurs ne sont pas transférées entre les outils.

Encoder et décoder les URL en programmation

Ces exemples utilisent la même valeur, hello + café, pour illustrer les espaces, un plus littéral et l’UTF-8. Encodez les noms et valeurs avant de les assembler ; n’encodez pas les séparateurs & et = de la requête. Les bibliothèques diffèrent pour la ponctuation, la casse hexadécimale, les entrées incorrectes et l’ordre. Les exemples présentent leurs API sans reproduire tous les contrôles de cet outil.

const value = "hello + café";
const encoded = encodeURIComponent(value);
console.log(encoded); // hello%20%2B%20caf%C3%A9
console.log(decodeURIComponent(encoded)); // hello + café

const query = new URLSearchParams([
  ["q", value], ["tag", "css"], ["tag", "html"]
]);
console.log(query.toString()); // q=hello+%2B+caf%C3%A9&tag=css&tag=html
console.log(query.getAll("tag")); // ["css", "html"]

from urllib.parse import quote, unquote, quote_plus, unquote_plus, urlencode, parse_qsl

value = "hello + café"
component = quote(value, safe="")
form = quote_plus(value, safe="")
print(component)  # hello%20%2B%20caf%C3%A9
print(unquote(component, errors="strict"))  # hello + café
print(form)  # hello+%2B+caf%C3%A9
print(unquote_plus(form, errors="strict"))  # hello + café

pairs = parse_qsl("tag=css&tag=html&empty=", keep_blank_values=True)
print(urlencode(pairs))  # tag=css&tag=html&empty=

<?php
$value = 'hello + café';
$component = rawurlencode($value);
$form = urlencode($value);

echo $component, PHP_EOL; // hello%20%2B%20caf%C3%A9
echo rawurldecode($component), PHP_EOL; // hello + café
echo $form, PHP_EOL; // hello+%2B+caf%C3%A9
echo urldecode($form), PHP_EOL; // hello + café

using System;
using System.Net;

string value = "hello + café";
string component = Uri.EscapeDataString(value);
string form = WebUtility.UrlEncode(value);

Console.WriteLine(component); // hello%20%2B%20caf%C3%A9
Console.WriteLine(Uri.UnescapeDataString(component)); // hello + café
Console.WriteLine(form); // hello+%2B+caf%C3%A9
Console.WriteLine(WebUtility.UrlDecode(form)); // hello + café

package main

import (
    "fmt"
    "net/url"
)

func main() {
    encoded := url.QueryEscape("hello + café")
    decoded, err := url.QueryUnescape(encoded)
    if err != nil {
        panic(err)
    }
    fmt.Println(encoded) // hello+%2B+caf%C3%A9
    fmt.Println(decoded) // hello + café

    query := url.Values{}
    query.Add("tag", "css")
    query.Add("tag", "html")
    fmt.Println(query.Encode()) // tag=css&tag=html
}

use form_urlencoded::{parse, Serializer};

fn main() {
    let query = Serializer::new(String::new())
        .append_pair("q", "hello + café")
        .append_pair("tag", "css")
        .append_pair("tag", "html")
        .finish();
    println!("{}", query); // q=hello+%2B+caf%C3%A9&tag=css&tag=html
    let pairs: Vec<(String, String)> = parse(query.as_bytes()).into_owned().collect();
    assert_eq!(pairs[0].1, "hello + café");
    assert_eq!(pairs[1].0, pairs[2].0);
}

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

public class UrlExample {
    public static void main(String[] args) {
        String value = "hello + café";
        String encoded = URLEncoder.encode(value, StandardCharsets.UTF_8);
        String decoded = URLDecoder.decode(encoded, StandardCharsets.UTF_8);
        System.out.println(encoded); // hello+%2B+caf%C3%A9
        System.out.println(decoded); // hello + café
    }
}

import Foundation

let value = "hello + café"
let allowed = CharacterSet(charactersIn:
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~")

if let encoded = value.addingPercentEncoding(withAllowedCharacters: allowed),
   let decoded = encoded.removingPercentEncoding {
    print(encoded) // hello%20%2B%20caf%C3%A9
    print(decoded) // hello + café
} else {
    print("Invalid text")
}

program UrlExample;

{$APPTYPE CONSOLE}

uses
  System.SysUtils, System.NetEncoding;

var
  Value, Encoded, Decoded: string;
begin
  Value := 'hello + caf' + Char($00E9);
  Encoded := TNetEncoding.URL.Encode(Value);
  Decoded := TNetEncoding.URL.Decode(Encoded);
  Writeln(Encoded);
  Writeln(Decoded);
end.

Références

• MDN : encodeURIComponent  - les règles JavaScript pour encoder un composant URL, notamment les caractères laissés tels quels et le traitement d’Unicode.
• MDN : URLSearchParams (traduction partielle)  - la manipulation des paramètres, les clés répétées et la sérialisation de formulaire. Cet outil refuse volontairement les échappements incorrects au lieu d’appliquer le décodage permissif de cette API.
• Standard URL du WHATWG (en anglais)  - la référence normative pour l’analyse et la sérialisation des URL, l’encodage en pourcentage et le format application/x-www-form-urlencoded.