URL Componenten Parser

Parseer elke URL of URI lokaal in je browser in scheme, auth, host, TLD, poort, padsegmenten, queryparameters en hash met live RFC 3986-bewerking.

Geen uploadsGeen registratieDirect resultaat
RFC 3986 / WHATWG URL-inspectorLive editor voor Host · Pad · Query · Hash100% Lokaal • Geen Uploads
URL parseren & bewerken
Offline engine gereed100% privé in-browser werkomgeving • Nul cloud-uploads
100% Privé • Geen Server Uploads

Waarom Utiliome's gratis URL Componenten Parser gebruiken?

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

WHATWG & RFC 3986 Componentanalyse

Ontleedt scheme, userinfo-inloggegevens, origin, hostnaam, subdomein, registreerbaar domein, TLD, expliciete of standaardpoort, geïndexeerde padsegmenten, query-paren en hash-fragment.

Live Bidirectionele URL-reconstructie

Bewerk afzonderlijke velden — zoals het wisselen van hostnamen, wijzigen van poorten, aanpassen van padsegmenten of bewerken van querywaarden — en stel direct een genormaliseerde URL opnieuw samen.

Ondersteuning voor IDN, IPv6 & Custom URI-schema's

Verwerkt geïnternationaliseerde Punycode-domeinen (xn--), IPv6-literals tussen blokhaken ([::1]:8080), niet-HTTP deep-link-schema's (myapp://) en interne endpoints met expliciete poorten.

100% Client-Side Inspectie zonder Datalekken

Draait volledig in het browsergeheugen, zodat OAuth-redirect-URL's, vooraf ondertekende AWS S3-links, webhook-tokens en basic-auth-inloggegevens nooit naar een server worden verzonden.

Utiliome vs. traditionele cloudtools

Vergelijk onze lokale WebAssembly-engine met verouderde cloudtools.

Functie Utiliome (Lokale Browser) Verouderde Cloud Converters
WHATWG & RFC 3986 Componentanalyse Ontleedt scheme, userinfo-inloggegevens, origin, hostnaam, subdomein, registreerbaar domein, TLD, expliciete of standaardpoort, geïndexeerde padsegmenten, query-paren en hash-fragment. Beperkte opties zonder geavanceerde aanpassing
Live Bidirectionele URL-reconstructie Bewerk afzonderlijke velden — zoals het wisselen van hostnamen, wijzigen van poorten, aanpassen van padsegmenten of bewerken van querywaarden — en stel direct een genormaliseerde URL opnieuw samen. 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 URL Componenten Parser te gebruiken in 3 eenvoudige stappen

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

1

Plak of upload een URL

Voer een HTTP(S)-adres, aangepast URI-schema, IPv6-service-endpoint of ondertekende callback-link in het invoerveld in, of sleep een tekstbestand naar de tool.

2

Inspecteer ontlede URI-velden

Bekijk de geparseerde origin, authority-inloggegevens, opsplitsing in subdomein/domein/TLD, gedecodeerde lijst met padsegmenten, sleutel-waardeparameters van de query en fragment-identifier.

3

Bewerk componenten en kopieer resultaat

Pas elk onderdeel onafhankelijk aan — wissel staging-hosts, wijzig poortnummers of werk parameters bij — en kopieer de herbouwde URL of de gestructureerde JSON-weergave.

Hoe het parseren van URL-componenten en live reconstructie werken

Kort antwoord: Een URL-parser splitst een Uniform Resource Identifier op langs structurele scheidingstekens volgens RFC 3986 (://, @, :, /, ?, #), en isoleert authority, hiërarchische padsegmenten, queryparameters en fragmentstatus zodat elk veld kan worden geïnspecteerd of aangepast zonder handmatige string-manipulatie.

Handmatige reguliere expressies en simpele split('/')-hulpfuncties lopen vaak vast op basic-auth-inloggegevens, expliciete poorten, procent-gecodeerde schuine strepen (%2F), meerdelige publieke extensies zoals .co.uk, of vraagtekens binnenin hash-fragmenten. Een parser die de specificaties volgt, scant scheidingstekens in strikte syntactische volgorde voordat individuele componenten worden gedecodeerd.

Neem bijvoorbeeld een complexe webhook-URL met inloggegevens, een subdomein met meerdere niveaus, een niet-standaard TLS-poort, een gecodeerd padsegment, queryparameters en een fragment-anker:

https://deploy:tok_9f8a@staging.api.example.co.uk:8443/v2/orgs/acme%20corp/webhooks?event=push&active=true#delivery-log

Het ontleden van deze URI levert afzonderlijke, onafhankelijk bewerkbare eigenschappen op:

{
  "href": "https://deploy:tok_9f8a@staging.api.example.co.uk:8443/v2/orgs/acme%20corp/webhooks?event=push&active=true#delivery-log",
  "protocol": "https:",
  "scheme": "https",
  "username": "deploy",
  "password": "tok_9f8a",
  "origin": "https://staging.api.example.co.uk:8443",
  "host": "staging.api.example.co.uk:8443",
  "hostname": "staging.api.example.co.uk",
  "subdomain": "staging.api",
  "domain": "example.co.uk",
  "tld": "co.uk",
  "port": "8443",
  "pathname": "/v2/orgs/acme%20corp/webhooks",
  "pathSegments": ["v2", "orgs", "acme corp", "webhooks"],
  "search": "?event=push&active=true",
  "queryParams": {
    "event": "push",
    "active": "true"
  },
  "hash": "#delivery-log"
}

Componenten aanpassen zonder escape-sequenties te beschadigen

Bij het debuggen tussen verschillende omgevingen wil je vaak een onderschepte productie- of staging-callback-URL naar een lokale service laten verwijzen, met behoud van de exacte padcodering en ondertekende query-payloads. Door scheme te wijzigen in http, hostname in localhost, port in 3000 en username/password leeg te maken, wordt de URL netjes gereconstrueerd:

http://localhost:3000/v2/orgs/acme%20corp/webhooks?event=push&active=true#delivery-log

Merk op dat het derde padsegment (acme corp) automatisch zijn %20-procentcodering binnen pathname behoudt, wat voorkomt dat spaties de URL afbreken in HTTP-requestregels of Markdown-logs.

RFC 3986 Generieke URI-syntaxis vs. de WHATWG URL-standaard

Kort antwoord: RFC 3986 definieert stateless ABNF-grammaticaregels voor generieke URI's, terwijl moderne browsers, Node.js, Deno en Cloudflare Workers de WHATWG URL Living Standard implementeren, die normalisatie van speciale schema's, weglating van standaardpoorten, backslash-conversie en UTS #46 Punycode IDNA-codering afdwingt.

Inzicht in de subtiele verschillen tussen RFC 3986 en de WHATWG URL-standaard voorkomt routeringsfouten, ongeldige handtekeningverificaties en kwetsbaarheden voor Server-Side Request Forgery (SSRF).

Canonieke structurele grammatica (RFC 3986 Sectie 3)

RFC 3986 verdeelt elke generieke URI van links naar rechts in vijf primaire componenten met vaste voorrang:

  foo://user:pass@example.com:8042/over/there?name=ferret#nose
  \_/   \_______________________/ \_________/ \_________/ \__/
   |                |                  |           |        |
scheme          authority             path       query   fragment
  • Scheme (Schema): Moet beginnen met een ASCII-letter gevolgd door letters, cijfers, +, - of . (ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )). Wordt genormaliseerd naar kleine letters.
  • Authority (Autoriteit): Voorafgegaan door // en beëindigd door de eerstvolgende /, ?, # of het einde van de string. Onderverdeeld in optionele userinfo@, host (geregistreerde naam, IPv4-adres of [IPv6]-literal tussen blokhaken) en optionele :port.
  • Path (Pad): Hiërarchische reeks van /-segmenten. Puntsegmenten (. en ..) worden opgelost via het remove_dot_segments-algoritme (RFC 3986 Sectie 5.2.4).
  • Query (Zoekopdracht): Ingeleid door het eerste ? na het pad en beëindigd door # of het einde van de string.
  • Fragment: Ingeleid door # en beslaat alle resterende tekens tot het einde van de URI, inclusief eventuele volgende ?- of /-tekens.

Speciale WHATWG-schema's vs. ondoorzichtige paden

De WHATWG URL-statemachine wijst zes schema's aan als speciaal (special): http, https, ws, wss, ftp en file. Speciale URL's ondergaan strikte normalisatie die niet-speciale schema's (mailto:, urn:, data:, myapp://) overslaan:

  1. Weglating van standaardpoorten (Default Port Elision): https://example.com:443/api wordt geserialiseerd als https://example.com/api met port ingesteld op "", omdat 443 overeenkomt met de standaardpoort voor https (80 voor http/ws, 443 voor https/wss, 21 voor ftp). Aangepaste schema's zoals redis://cache.internal:6379 behouden :6379.
  2. Backslash-normalisatie: In speciale schema's worden backslashes (\) binnen authority- en padsegmenten genormaliseerd naar voorwaartse schuine strepen (/), terwijl niet-speciale schema's \ behandelen als een regulier padteken.
  3. Schuine streep bij leeg pad: https://example.com wordt geserialiseerd met een afsluitende root-slash (pathname = "/"), terwijl custom://host een lege pathname kan hebben.
  4. IDNA Punycode-conversie: Unicode-domeinlabels zoals https://münchen.example/path worden via UTS #46 geconverteerd naar ASCII Compatible Encoding (https://xn--mnchen-3ya.example/path) in de hostname-eigenschap.

IPv6-literals en samengestelde Public Suffixes

IPv6-adressen bevatten dubbele punten die zouden botsen met het :port-scheidingsteken tenzij ze tussen vierkante haken staan volgens RFC 2732, zoals in http://[2001:db8:85a3::8a2e:370:7334]:8080/health. Daarnaast kan het opsplitsen van een hostnaam in subdomein, registreerbaar domein en TLD niet simpelweg bij de laatste punt gebeuren: landspecifieke second-level domeinen (example.co.uk, app.com.au) en platform-extensies vereisen herkenning van samengestelde extensies, zodat co.uk wordt herkend als de effectieve TLD in plaats van alleen uk.

Beveiligingsopmerking: Parser-verschillen en SSRF

Beveiligings-allowlists falen wanneer een proxy een URL valideert met een soepele RFC 3986-regex terwijl de achterliggende HTTP-client deze ophaalt met een WHATWG-parser. Invoer met meerdere @-scheidingstekens (https://allowed.example@169.254.169.254/latest/meta-data/) of backslashes (https://attacker.example\@allowed.example/) kan ervoor zorgen dat de ene parser allowed.example als host leest, terwijl de HTTP-client verbinding maakt met 169.254.169.254 of attacker.example. Valideer origin en hostname altijd na het parseren met exact dezelfde WHATWG-normalisatie die je HTTP-client gebruikt, en verwijder of weiger onverwachte username/password-authorityvelden.

URL Componenten Parser vs. Query String Parser vs. URL Encoder: Welke tool heb je nodig?

Kort antwoord: Gebruik de URL Componenten Parser om de volledige URI-structuur over scheme, authority, host, poort, pad, query en hash te inspecteren en te herbouwen. Gebruik de Query String Parser voor het bewerken van diep geneste query's en bidirectionele JSON-conversie, of de URL Encoder & Decoder om ruwe tekststrings te escapen.

Taken rondom URL-manipulatie vallen uiteen in verschillende syntactische lagen. Door de tool te kiezen die specifiek voor jouw laag is gebouwd, voorkom je dat scheidingstekens dubbel worden gecodeerd of dat geneste parametertypen verloren gaan.

Functie URL Componenten Parser (Deze tool) Query String Parser URL Encoder & Decoder Procent-encoder
Primaire invoer Volledige URL of aangepaste URI ?a=1&b=2, formulier-body of JSON Ruwe string of gecodeerd URL-onderdeel Ruwe tekst voor strikte RFC 3986 %XX-escaping
Authority, Host, Poort & TLD-splitsing Volledige analyse + live bewerken Verwijdert niet-query URL-delen Geen structurele parsing Geen structurele parsing
Inspectie van padsegmenten Geïndexeerde gedecodeerde pad-array Niet van toepassing Geen structurele parsing Geen structurele parsing
Geneste Query-arrays & Blokhaken Platte sleutel-waarde query-inspectie Volledige tag[]=a, filter[k]=v & JSON-sync Niet van toepassing Niet van toepassing
Spatiecodering (+ vs. %20) Standaard URI-componentregels Configureerbare + of %20 serialisatie Ondersteunt component- & formulier-escaping Strikte RFC 3986 %20 byte-codering

Wanneer schakel je over naar een verwante tool?

  • Diep geneste API-filters bewerken of queryparameters omzetten naar JSON: Open de Query String Parser wanneer je werkt met herhaalde array-sleutels (?id=1&id=2), blokhaaknotatie in qs-stijl (filter[status]=open), application/x-www-form-urlencoded POST-payloads of JSON-testfixtures.
  • Een losse parameterwaarde escapen of decoderen: Gebruik de URL Encoder & Decoder wanneer je een ruwe string hebt met &, =, + of Unicode-tekens die veilig moeten worden geëscaped volgens encodeURIComponent-semantiek voordat je ze invoegt.
  • Strikte RFC 3986 byte-level escaping voor OAuth / AWS SigV4: Gebruik de Procent-encoder bij het ondertekenen van canonieke verzoeken waarbij tekens zoals !, ', (, ) en * hexadecimaal gecodeerd moeten worden.
  • Schone SEO-padsegmenten genereren uit titels: Gebruik URL Opschonen & Slugify om menselijke titels om te zetten naar kleine letters met koppeltekens voor pad-slugs.
Veelgestelde vragen

URL Componenten Parser FAQ en Technische Gids

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

Wat is het verschil tussen host, hostname en origin in een geparseerde URL?

In de WHATWG URL-specificatie bevat hostname alleen de domeinnaam of het IPv6-literal tussen blokhaken (api.example.com of [::1]). host voegt alleen :port toe wanneer er een expliciete, niet-standaard poort aanwezig is (api.example.com:8443, of api.example.com bij gebruik van poort 443 over https). origin plaatst het scheme en het ://-scheidingsteken vóór host (https://api.example.com:8443) en vertegenwoordigt de webbeveiligingsgrens die wordt gebruikt door CORS en postMessage.

Waarom blijft een querystring na een hash (#) binnen het fragment in plaats van queryParams?

Volgens RFC 3986 Sectie 3.5 beëindigt het eerste #-scheidingsteken het pad- of query-onderdeel en start het de fragment-identifier, die doorloopt tot het einde van de URI. In hash-gerouteerde single-page application-links zoals https://app.example.com/#/orders?status=paid maakt ?status=paid deel uit van de client-side hash (#/orders?status=paid) en wordt deze nooit naar de HTTP-server verzonden. Om parameters binnen een hash-route te parseren, kopieer je de substring vanaf het ? naar de Query String Parser.

Waarom verdwijnen standaardpoorten zoals :80 en :443 bij het herbouwen van een HTTP- of HTTPS-URL?

Speciale schema's in de WHATWG URL-standaard definiëren standaardpoorten (80 voor http en ws, 443 voor https en wss, 21 voor ftp). Wanneer een URL expliciet de standaardpoort van zijn schema opgeeft — zoals https://example.com:443/v1 — laten conforme normalizers :443 weg tijdens canonieke serialisatie zodat gelijkwaardige origins identiek worden vergeleken. Niet-standaardpoorten zoals :8443 of :3000 blijven altijd behouden.

Hoe worden procent-gecodeerde schuine strepen (%2F) binnen padsegmenten afgehandeld?

Structurele /-scheidingstekens worden gesplitst voordat procent-decodering plaatsvindt. In /repos/acme%2Fcore/commits levert het splitsen eerst drie segmenten op (["repos", "acme%2Fcore", "commits"]), waarna decodering op segmentniveau acme/core oplevert als één enkele identifier. Als %2F vóór het splitsen van het pad zou worden gedecodeerd, zouden er ten onrechte vier padsegmenten ontstaan en zou REST-routematching breken.

Is het veilig om hier OAuth-callback-URL's of vooraf ondertekende AWS S3-URL's te inspecteren?

Ja. Alle URL-parsing, het bewerken van componenten en JSON-serialisatie worden 100% lokaal uitgevoerd binnen de JavaScript-runtime van je browser. Er worden nooit netwerkverzoeken, analytics-beacons of server-side logs gebruikt die in aanraking komen met je geplakte URL's, X-Amz-Signature-parameters, code-grants of userinfo-inloggegevens.