Query String Parser

Parse URL query strings and form-urlencoded payloads into editable key-value tables and JSON locally in-browser with array, bracket, and space decoding.

No uploadsNo sign-upInstant results
Interactive Key-Value Toggle EditorArrays & Nested Brackets → JSONx-www-form-urlencoded (+) vs Strict %20
Parse Query String
Offline engine ready100% private in-browser workspace • Zero cloud uploads
100% Private • Zero Server File Uploads

Why Use Utiliome's Free Query String Parser?

Built from the ground up for strict privacy, instant execution, and zero friction. No subscriptions, paywalls, or account registrations required.

Bidirectional Query String & JSON Converter

Parse ?key=value strings or application/x-www-form-urlencoded bodies into clean JSON objects and serialize edited JSON straight back into normalized query parameters.

Repeated Array Keys & Nested Bracket Syntax

Resolves duplicate keys (?tag=go&tag=rust), explicit array brackets (ids[]=1&ids[]=2), and nested object hierarchies (filter[status]=open&page[limit]=50).

Configurable + vs %20 Space Serialization

Decodes both + and %20 spaces on input per URLSearchParams rules, while letting you export strict RFC 3986 (%20) or HTML form (+) space encoding on rebuild.

Zero-Upload Interactive Parameter Table

Add, toggle, edit, or delete parameters locally in browser memory without exposing API keys, OAuth state tokens, or webhook payloads to external servers.

Utiliome vs Traditional Cloud Alternatives

Compare our local-first WebAssembly engine against legacy cloud tools.

Feature Utiliome (Local Browser) Legacy Cloud Converters
Nested Bracket & Array Notation Parses repeated keys (?id=1&id=2), bracket arrays (a[]=1), and nested objects Overwrites duplicate keys silently and treats filter[status] as a flat string
RFC 3986 vs WHATWG Form Space Decoding Properly decodes both %20 and application/x-www-form-urlencoded + spaces Leaves + signs literal inside decoded parameter values
Live Bidirectional JSON ↔ Query Editor Edit parameters in a structured table or JSON tree and rebuild the URL query live Read-only key/value output requiring manual string concatenation to rebuild
OAuth & Signed URL Confidentiality 100% local in-browser parsing — presigned S3 URLs and OAuth tokens stay private Sends full URLs containing API keys and session tokens to server logs
How it works

How to Use Query String Parser in 3 Easy Steps

No software installation required. Everything runs directly inside your web browser.

1

Paste a Query String, Full URL, or JSON

Enter a raw ?a=1&b=2 query string, a full URL (the parser isolates the search component automatically), an application/x-www-form-urlencoded body, or valid JSON.

2

Edit Keys, Arrays, and Encoding Options

Modify decoded names and values in the interactive key-value table or JSON editor, toggle individual rows on or off, and select your array and space encoding mode.

3

Copy the Rebuilt Query String or JSON

Copy the cleanly escaped query string for cURL commands and API clients, or export the structured JSON document directly into test suites and request fixtures.

Converting Complex Query Strings and Form Payloads to JSON

Quick Answer: A query string parser splits input bytes on & delimiters before decoding, separates each token on its first =, decodes + and %XX UTF-8 sequences, and aggregates repeated or bracketed keys (tag=a&tag=b, filter[status]=open) into JSON arrays and nested objects.

Modern REST, GraphQL-over-GET, and webhook endpoints regularly pack multi-value arrays, nested filter objects, Base64 cursors, and URL-encoded search phrases into a single query string or application/x-www-form-urlencoded request body. Inspecting or editing those payloads as a flat raw string invites broken %26 escapes and mismatched brackets.

Consider an API search query combining +-encoded whitespace, repeated keys, nested bracket filters, a Base64 pagination cursor with percent-encoded = padding, and a bare flag parameter:

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

Parsing this string produces an immediately readable, strongly structured JSON representation:

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

Why Delimiter Splitting Must Precede Percent-Decoding

Notice how cursor=eyJpZCI6NDIwfQ%3D%3D decodes cleanly to "eyJpZCI6NDIwfQ==". The parser splits the raw string on & first, splits each pair on the first literal =, and only then decodes + and %XX sequences. If a naive script ran decodeURIComponent() across the entire query string before splitting on & and =, any parameter value containing an escaped ampersand (R%26D -> R&D) would fracture into two bogus parameters.

Because the JSON view and key-value table stay synchronized bidirectionally, you can also paste a JSON filter object from your application code and immediately serialize a properly escaped query string ready for HTTP requests.

WHATWG URLSearchParams vs RFC 3986 and Backend Array Conventions

Quick Answer: RFC 3986 treats the query component as an unstructured string where spaces encode as %20 and + remains literal, whereas the WHATWG application/x-www-form-urlencoded standard (URLSearchParams) encodes spaces as + and leaves array and nested-object syntax to framework conventions.

Two distinct specifications govern query strings on the web, and mismatches between them account for some of the most common signature failures and parameter bugs in HTTP integrations.

The `application/x-www-form-urlencoded` Algorithm vs RFC 3986

HTML forms and the JavaScript URLSearchParams API implement the WHATWG application/x-www-form-urlencoded parser:

  1. Strip a leading ? if extracting from location.search.
  2. Split input on byte 0x26 (&), ignoring empty byte sequences from && or leading &.
  3. For each chunk, split at the first 0x3D (=). If no = is present, the entire chunk becomes the name and the value defaults to "".
  4. Replace every 0x2B (+) byte in both name and value with 0x20 (ASCII space).
  5. Percent-decode %XX hex byte sequences as UTF-8, replacing malformed byte sequences with U+FFFD.

By contrast, RFC 3986 Section 3.4 defines the URI query component without special-casing + as a space. Strict cryptographic signing protocols—most notably AWS Signature Version 4 and OAuth 2.0 / RFC 5849 canonical requests—require spaces to be encoded as %20 and + to be encoded as %2B. When targeting signed APIs, rebuild your query string using %20 space serialization rather than +.

Array and Object Serialization Across Frameworks

Neither RFC 3986 nor URLSearchParams standardizes nested arrays or objects. Backend ecosystems evolved four primary conventions:

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

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

# 3. Indexed brackets (Node.js qs ordered arrays)
?tag[0]=otel&tag[1]=grpc

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

Know what your target server expects before serializing: sending tag=otel&tag=grpc to standard PHP $_GET['tag'] overwrites the first value and returns scalar "grpc" unless tag[] brackets are used, whereas Go's r.URL.Query()["tag"] expects unbracketed tag keys.

Security Properties: HTTP Parameter Pollution and Prototype Pollution

  • HTTP Parameter Pollution (HPP): When duplicate scalar keys arrive (?account=user_1&account=user_2), server runtimes resolve the collision inconsistently: Python urllib.parse.parse_qs and Go Values.Get() read the first value, PHP and Ruby Rack read the last value, and Node/Express populates an array (["user_1", "user_2"]). If an API gateway checks permissions against the first occurrence while the upstream microservice processes the last occurrence, authorization checks can be bypassed.
  • Prototype Pollution in Bracket Parsers: Naive JavaScript bracket parsers that assign obj[key1][key2] = val directly on Object.prototype are vulnerable to payloads like ?__proto__[isAdmin]=true or ?constructor[prototype][isAdmin]=true. Safe parsers instantiate Object.create(null) dictionaries, block reserved prototype keys, and enforce nesting depth limits.

Query String Parser vs URL Component Parser vs URL Encoder: Which Tool Do You Need?

Quick Answer: Use Query String Parser for interactive parameter editing, array/bracket parsing, and bidirectional JSON conversion. Use URL Component Parser when you need to split or edit scheme, host, port, path segments, and hash, or URL Encoder & Decoder to escape raw individual strings.

Each tool in Utiliome's URL cluster handles a distinct scope so you get dedicated controls without unnecessary clutter:

Feature Query String Parser (This Tool) URL Component Parser URL Encoder & Decoder Percent Encoder
Primary Focus Query parameters, form bodies & JSON sync Complete URI anatomy (RFC 3986 / WHATWG) Escaping & unescaping raw strings Strict RFC 3986 %XX byte encoding
Bidirectional JSON Conversion Full support (nested objects & arrays) Read-only JSON export of URI fields Not applicable Not applicable
Array & Bracket Syntax (a[]=1, f[k]=v) Native parsing & configurable rebuild Flat query pair display Not applicable Not applicable
+ vs %20 Space Serialization Toggle Configurable on output Standard URI component normalization Component (%20) & form (+) modes Strict %20 only
Scheme, Host, Port, TLD & Path Editing Strips non-query URL parts automatically Full component editor & reconstructor No structural parsing No structural parsing

Choosing the Right Workflow

  • Inspecting or modifying scheme, subdomain, TLD, port, path segments, or fragment: Switch to the URL Component Parser to view and reconstruct the entire URL across every RFC 3986 boundary.
  • Escaping a single raw value containing reserved characters (&, =, +, /): Use the URL Encoder & Decoder to encode or decode individual strings cleanly.
  • Generating strict RFC 3986 canonical escapes (!, ', (, ), * -> %XX): Use the Percent Encoder when constructing OAuth 1.0a or AWS SigV4 canonical query values.
FAQ

Query String Parser FAQ and Technical Guide

Everything you need to know about using Utiliome's free online query string parser.

Why does a literal plus sign (+) in a URL parameter decode as a space?

Under the application/x-www-form-urlencoded standard and browser URLSearchParams, 0x2B (+) represents an encoded space (0x20). If your parameter value contains a literal plus sign—such as an ISO 8601 timestamp offset (2026-11-01T09:30:00+01:00), a Base64 token, or an E.164 phone number (+14155550100)—it must be transmitted as %2B. You can escape raw individual strings beforehand in the URL Encoder & Decoder.

How are repeated keys like ?tag=api&tag=cli represented when converted to JSON?

Because RFC 8259 JSON objects require unique keys at each level, duplicate parameter names are grouped in order of appearance into a JSON array: { "tag": ["api", "cli"] }. When converting that JSON array back into a query string, you can serialize it as repeated keys (tag=api&tag=cli), empty brackets (tag[]=api&tag[]=cli), or indexed brackets (tag[0]=api&tag[1]=cli).

Can I paste a complete URL or an application/x-www-form-urlencoded POST body directly?

Yes. When you paste a full URL like https://api.example.com/v2/events?limit=25&cursor=abc#section, the parser automatically isolates the query substring between ? and # (limit=25&cursor=abc). Raw application/x-www-form-urlencoded request bodies without a leading ? parse identically. If you also need to edit the hostname, port, path segments, or hash, open the address in the URL Component Parser.

What happens to bare flag parameters without an equals sign, like ?debug or ?dry_run?

Per the WHATWG URLSearchParams parsing algorithm, a parameter chunk without = sets the decoded parameter key to the chunk name ("dry_run") and its value to an empty string (""). In the interactive table you can assign an explicit value like true, delete the parameter, or keep it empty.

Are API keys, OAuth tokens, or webhook parameters sent to any backend server?

No. Parsing, table editing, and JSON serialization run 100% locally in your browser using client-side JavaScript. Sensitive query credentials, access_token values, and internal analytics payloads never leave your machine.