Querystring-parser

Parse URL-querystrings en form-urlencoded data in je browser naar bewerkbare key-value-tabellen en JSON met decodering van arrays en brackets.

Geen uploadsGeen registratieDirect resultaat
Interactieve sleutel-waarde-editorArrays & geneste haken → JSONx-www-form-urlencoded (+) vs. strikt %20
Querystring parseren
Offline engine gereed100% privé in-browser werkomgeving • Nul cloud-uploads
100% Privé • Geen Server Uploads

Waarom Utiliome's gratis Querystring-parser gebruiken?

Van de grond af opgebouwd voor strikte privacy, directe uitvoering en nul wrijving. Geen registratie nodig.

Bidirectionele Query String & JSON Converter

Parse ?key=value-strings of application/x-www-form-urlencoded-bodies naar overzichtelijke JSON-objecten en serialiseer bewerkte JSON direct terug naar genormaliseerde queryparameters.

Herhaalde Array-keys & Geneste Bracketsyntax

Verwerkt dubbele keys (?tag=go&tag=rust), expliciete arrayhaken (ids[]=1&ids[]=2) en geneste objecthiërarchieën (filter[status]=open&page[limit]=50).

Configureerbare + vs %20 Spatieserialisatie

Decodeert bij invoer zowel + als %20 spaties volgens de URLSearchParams-regels, terwijl je bij het opbouwen kunt kiezen tussen strikte RFC 3986 (%20) of HTML-formulier (+) spatiecodering.

Interactieve Parametertabel zonder Upload

Voeg parameters toe, schakel ze in of uit, bewerk of verwijder ze lokaal in het browsergeheugen zonder API-keys, OAuth-statetokens of webhook-payloads bloot te stellen aan externe servers.

Utiliome vs. traditionele cloudtools

Vergelijk onze lokale WebAssembly-engine met verouderde cloudtools.

Functie Utiliome (Lokale Browser) Verouderde Cloud Converters
Bidirectionele Query String & JSON Converter Parse ?key=value-strings of application/x-www-form-urlencoded-bodies naar overzichtelijke JSON-objecten en serialiseer bewerkte JSON direct terug naar genormaliseerde queryparameters. Beperkte opties zonder geavanceerde aanpassing
Herhaalde Array-keys & Geneste Bracketsyntax Verwerkt dubbele keys (?tag=go&tag=rust), expliciete arrayhaken (ids[]=1&ids[]=2) en geneste objecthiërarchieën (filter[status]=open&page[limit]=50). Vereist externe tools of handmatige bewerking
Privacy & Gegevensverwerking 100% lokale verwerking in je browser (geen uploads) Uploadt gegevens naar externe cloudservers
Prijsmodel & Accountvereisten 100% gratis voor altijd zonder registratie Vereist accountregistratie of betaald abonnement
Hoe het werkt

Hoe Querystring-parser te gebruiken in 3 eenvoudige stappen

Geen software-installatie vereist. Alles draait direct in je webbrowser.

1

Plak een Querystring, Volledige URL of JSON

Voer een ruwe ?a=1&b=2-querystring, een volledige URL (de parser isoleert het zoekgedeelte automatisch), een application/x-www-form-urlencoded-body of geldige JSON in.

2

Bewerk Keys, Arrays en Coderingsopties

Pas gedecodeerde namen en waarden aan in de interactieve key-value-tabel of JSON-editor, schakel afzonderlijke rijen in of uit en selecteer de gewenste array- en spatiecoderingsmodus.

3

Kopieer de Opgebouwde Querystring of JSON

Kopieer de correct geëscapete querystring voor cURL-commando's en API-clients, of exporteer het gestructureerde JSON-document rechtstreeks naar testsuites en request-fixtures.

Complexe Querystrings en Formulier-payloads Converteren naar JSON

Kort antwoord: Een query string parser splitst invoerbytes op &-scheidingstekens vóór het decoderen, scheidt elk token op het eerste =-teken, decodeert +- en %XX-UTF-8-reeksen en groepeert herhaalde of tussen haken geplaatste keys (tag=a&tag=b, filter[status]=open) in JSON-arrays en geneste objecten.

Moderne REST-, GraphQL-over-GET- en webhook-endpoints combineren regelmatig arrays met meerdere waarden, geneste filterobjecten, Base64-cursors en URL-gecodeerde zoektermen in één enkele querystring of application/x-www-form-urlencoded request-body. Het inspecteren of bewerken van zulke payloads als een platte ruwe string leidt al snel tot kapotte %26-escapes en niet-sluitende haken.

Neem bijvoorbeeld een API-zoekopdracht die +-gecodeerde witruimte, herhaalde keys, geneste bracketfilters, een Base64-pagineringscursor met procent-gecodeerde =-padding en een losse flag-parameter combineert:

?q=distributed+tracing&tag=otel&tag=grpc&filter[status]=open&filter[priority]=high&cursor=eyJpZCI6NDIwfQ%3D%3D&dry_run

Het parsen van deze string levert een direct leesbare, sterk gestructureerde JSON-weergave op:

{
  "q": "distributed tracing",
  "tag": [
    "otel",
    "grpc"
  ],
  "filter": {
    "status": "open",
    "priority": "high"
  },
  "cursor": "eyJpZCI6NDIwfQ==",
  "dry_run": ""
}

Waarom Splitsen op Scheidingstekens Vóór Procent-decodering Moet Gebeuren

Merk op hoe cursor=eyJpZCI6NDIwfQ%3D%3D netjes wordt gedecodeerd naar "eyJpZCI6NDIwfQ==". De parser splitst de ruwe string eerst op &, splitst elk paar op het eerste letterlijke =-teken en decodeert pas daarna +- en %XX-reeksen. Als een naïef script decodeURIComponent() op de volledige querystring zou uitvoeren vóór het splitsen op & en =, zou elke parameterwaarde met een geëscapete ampersand (R%26D -> R&D) uiteenvallen in twee foutieve parameters.

Omdat de JSON-weergave en de key-value-tabel bidirectioneel gesynchroniseerd blijven, kun je ook een JSON-filterobject uit je applicatiecode plakken en direct een correct geëscapete querystring serialiseren die klaar is voor HTTP-requests.

WHATWG URLSearchParams vs RFC 3986 en Backend Array-conventies

Kort antwoord: RFC 3986 behandelt de querycomponent als een ongestructureerde string waarin spaties worden gecodeerd als %20 en + letterlijk blijft, terwijl de WHATWG application/x-www-form-urlencoded-standaard (URLSearchParams) spaties codeert als + en de syntax voor arrays en geneste objecten overlaat aan frameworkconventies.

Er zijn twee verschillende specificaties die querystrings op het web reguleren, en verschillen daartussen vormen een van de meest voorkomende oorzaken van ongeldige ondertekeningen en parameterbugs in HTTP-integraties.

Het `application/x-www-form-urlencoded`-algoritme vs RFC 3986

HTML-formulieren en de JavaScript URLSearchParams-API implementeren de WHATWG application/x-www-form-urlencoded-parser:

  1. Verwijder een voorloop-? bij extractie uit location.search.
  2. Splits de invoer op byte 0x26 (&), waarbij lege bytereeksen door && of een voorloop-& worden genegeerd.
  3. Splits elk deel bij het eerste 0x3D-byte (=). Als er geen = aanwezig is, wordt het gehele deel de naam en krijgt de waarde standaard "".
  4. Vervang elk 0x2B-byte (+) in zowel naam als waarde door 0x20 (ASCII-spatie).
  5. Procent-decodeer %XX-hex-bytereeksen als UTF-8, waarbij ongeldige bytereeksen worden vervangen door U+FFFD.

Daarentegen definieert RFC 3986 Sectie 3.4 de URI-querycomponent zonder + als speciaal geval voor een spatie te behandelen. Strikte cryptografische ondertekeningsprotocollen — met name AWS Signature Version 4 en canonieke requests onder OAuth 2.0 / RFC 5849 — vereisen dat spaties worden gecodeerd als %20 en + als %2B. Wanneer je werkt met ondertekende API's, bouw je de querystring opnieuw op met %20-spatieserialisatie in plaats van +.

Array- en Objectserialisatie in Verschillende Frameworks

Noch RFC 3986, noch URLSearchParams standaardiseert geneste arrays of objecten. Binnen backend-ecosystemen zijn vier hoofdconventies ontstaan:

# 1. Herhaalde keys (WHATWG URLSearchParams.getAll, Go net/url, Python parse_qs, Java Servlet)
?tag=otel&tag=grpc

# 2. Ongeïndexeerde haken (PHP $_GET, Ruby on Rails / Rack, Express qs)
?tag[]=otel&tag[]=grpc

# 3. Geïndexeerde haken (Node.js qs geordende arrays)
?tag[0]=otel&tag[1]=grpc

# 4. Geneste object-keys (Node.js qs, Rails, PHP, Stripe REST API)
?filter[status]=open&filter[created][gte]=1730000000

Controleer wat je doelserver verwacht voordat je serialiseert: het sturen van tag=otel&tag=grpc naar standaard PHP $_GET['tag'] overschrijft de eerste waarde en retourneert de scalaire waarde "grpc" tenzij tag[]-haken worden gebruikt, terwijl Go's r.URL.Query()["tag"] juist tag-keys zonder haken verwacht.

Beveiligingsaspecten: HTTP Parameter Pollution en Prototype Pollution

  • HTTP Parameter Pollution (HPP): Wanneer dubbele scalaire keys binnenkomen (?account=user_1&account=user_2), lossen server-runtimes de botsing verschillend op: Python urllib.parse.parse_qs en Go Values.Get() lezen de eerste waarde, PHP en Ruby Rack lezen de laatste waarde, en Node/Express vult een array (["user_1", "user_2"]). Als een API-gateway rechten controleert op basis van het eerste voorkomen terwijl de achterliggende microservice het laatste voorkomen verwerkt, kunnen autorisatiecontroles worden omzeild.
  • Prototype Pollution in Bracket-parsers: Naïeve JavaScript bracket-parsers die obj[key1][key2] = val rechtstreeks toewijzen op een object met Object.prototype zijn kwetsbaar voor payloads zoals ?__proto__[isAdmin]=true of ?constructor[prototype][isAdmin]=true. Veilige parsers instantiëren dictionaries met Object.create(null), blokkeren gereserveerde prototype-keys en dwingen limieten voor de nestdiepte af.

Query String Parser vs URL Componenten Parser vs URL Encoder: Welke Tool Heb Je Nodig?

Kort antwoord: Gebruik de Query String Parser voor het interactief bewerken van parameters, het parsen van arrays/haken en bidirectionele JSON-conversie. Gebruik de URL Componenten Parser wanneer je scheme, host, poort, padsegmenten en hash wilt splitsen of bewerken, of de URL Encoder & Decoder om losse ruwe strings te escapen.

Elke tool in het URL-cluster van Utiliome behandelt een specifiek toepassingsgebied, zodat je gerichte bedieningselementen krijgt zonder onnodige rommel:

Functie Query String Parser (Deze Tool) URL Componenten Parser URL Encoder & Decoder Procent-encoder
Primaire Focus Queryparameters, formulier-bodies & JSON-synchronisatie Volledige URI-anatomie (RFC 3986 / WHATWG) Escapen & decoderen van ruwe strings Strikte RFC 3986 %XX bytecodering
Bidirectionele JSON-conversie Volledige ondersteuning (geneste objecten & arrays) Alleen-lezen JSON-export van URI-velden Niet van toepassing Niet van toepassing
Array- & Bracketsyntax (a[]=1, f[k]=v) Native parsen & configureerbaar opbouwen Platte weergave van queryparen Niet van toepassing Niet van toepassing
+ vs %20 Spatieserialisatie-schakelaar Configureerbaar bij uitvoer Standaard normalisatie van URI-componenten Component- (%20) & formuliermodus (+) Alleen strikte %20
Scheme, Host, Poort, TLD & Pad Bewerken Verwijdert niet-query URL-delen automatisch Volledige component-editor & reconstructor Geen structurele parsing Geen structurele parsing

De Juiste Workflow Kiezen

  • Scheme, subdomein, TLD, poort, padsegmenten of fragment inspecteren of wijzigen: Schakel over naar de URL Componenten Parser om de volledige URL over elke RFC 3986-grens heen te bekijken en opnieuw op te bouwen.
  • Een losse ruwe waarde met gereserveerde tekens (&, =, +, /) escapen: Gebruik de URL Encoder & Decoder om afzonderlijke strings netjes te coderen of decoderen.
  • Strikte canonieke RFC 3986-escapes genereren (!, ', (, ), * -> %XX): Gebruik de Procent-encoder bij het opstellen van canonieke querywaarden voor OAuth 1.0a of AWS SigV4.
Veelgestelde vragen

Querystring-parser FAQ en Technische Gids

Alles wat je moet weten over het gebruik van Utiliome's gratis online query string parser.

Waarom wordt een letterlijk plusteken (+) in een URL-parameter gedecodeerd als een spatie?

Volgens de application/x-www-form-urlencoded-standaard en URLSearchParams in de browser staat 0x2B (+) voor een gecodeerde spatie (0x20). Als je parameterwaarde een letterlijk plusteken bevat — zoals een ISO 8601 tijdstempel-offset (2026-11-01T09:30:00+01:00), een Base64-token of een E.164-telefoonnummer (+14155550100) — moet dit worden verzonden als %2B. Je kunt losse ruwe strings vooraf escapen in de URL Encoder & Decoder.

Hoe worden herhaalde keys zoals ?tag=api&tag=cli weergegeven bij conversie naar JSON?

Omdat RFC 8259 JSON-objecten op elk niveau unieke keys vereisen, worden dubbele parameternamen op volgorde van voorkomen gegroepeerd in een JSON-array: { "tag": ["api", "cli"] }. Wanneer je die JSON-array terugconverteert naar een querystring, kun je deze serialiseren als herhaalde keys (tag=api&tag=cli), lege haken (tag[]=api&tag[]=cli) of geïndexeerde haken (tag[0]=api&tag[1]=cli).

Kan ik een volledige URL of een application/x-www-form-urlencoded POST-body rechtstreeks plakken?

Ja. Wanneer je een volledige URL plakt zoals https://api.example.com/v2/events?limit=25&cursor=abc#section, isoleert de parser automatisch de querysubstring tussen ? en # (limit=25&cursor=abc). Ruwe application/x-www-form-urlencoded request-bodies zonder voorloop-? worden op exact dezelfde manier geparset. Als je ook de hostnaam, poort, padsegmenten of hash wilt bewerken, open je het adres in de URL Componenten Parser.

Wat gebeurt er met losse flag-parameters zonder is-gelijkteken, zoals ?debug of ?dry_run?

Volgens het WHATWG URLSearchParams-parse-algoritme stelt een parameterdeel zonder = de gedecodeerde parameter-key in op de naam van dat deel ("dry_run") en de waarde op een lege string (""). In de interactieve tabel kun je een expliciete waarde zoals true toewijzen, de parameter verwijderen of deze leeg laten.

Worden API-keys, OAuth-tokens of webhook-parameters naar een backendserver verzonden?

Nee. Het parsen, het bewerken in de tabel en de JSON-serialisatie draaien 100% lokaal in je browser met client-side JavaScript. Gevoelige query-inloggegevens, access_token-waarden en interne analytics-payloads verlaten je apparaat nooit.