Skip to content

traceparent-decoder — W3C Trace Context

Stop met hexcijfers tellen. Gratis online traceparent-decoder — draait in je browser, geen upload. Trace-ID, span-ID, 8 trace-flags-bits, tracestate, Datadog/X-Ray/B3.

Geen tracking Draait in je browser Gratis
Alles wordt lokaal in je browser gedecodeerd — de headers die je plakt verlaten dit apparaat nooit. Open het Network-paneel en zie het stil blijven, of ga volledig offline.
Probeer een voorbeeld
Velden uitgesplitst
Version
00
Trace ID
4bf92f3577b34da6a3ce929d0e0e4736
Parent ID (span ID)
00f067aa0ba902b7
Trace flags
01
trace-flags, bit voor bit
Bit Masker Naam Status
0 0x01 sampled 1
1 0x02 random-trace-id 0
2 0x04 gereserveerd 0
3 0x08 gereserveerd 0
4 0x10 gereserveerd 0
5 0x20 gereserveerd 0
6 0x40 gereserveerd 0
7 0x80 gereserveerd 0

Lees deze met een bitsgewijze AND. Het hele byte met 01 vergelijken rapporteert elke trace verkeerd die ook een gereserveerd bit draagt.

Andere propagatieformaten
x-datadog-trace-id
11803532876627986230
x-datadog-tags: _dd.p.tid
4bf92f3577b34da6
x-datadog-parent-id
67667974448284343
AWS X-Ray trace-ID
1-4bf92f35-77b34da6a3ce929d0e0e4736
b3 (single header)
4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-1
X-B3-TraceId
4bf92f3577b34da6a3ce929d0e0e4736
X-B3-SpanId
00f067aa0ba902b7
X-B3-Sampled
1

Datadog draagt de onderste 64 bits van de trace-ID als decimale string en de bovenste 64 bits hexadecimaal in een tag. De volledige 128-bits waarde als decimaal doorgeven is de klassieke reden dat een trace-ID uit je logs niets vindt in de UI.

Een X-Ray-ID bevat een 32-bits timestamp; een W3C trace-ID draagt helemaal geen timestamp. De datum hieronder is alleen zinvol als de identifier daadwerkelijk uit X-Ray komt.

tracestate-members 2/32
# Sleutel Waarde Status
1 rojo 00f067aa0ba902b7 OK
2 congo t61rcWkgMzE OK

traceparent-formaat: anatomie van de velden

traceparent-formaat: anatomie van de velden
Veld Hexcijfers Bytes Betekenis Ongeldige waarde
version 2 1 Formaatversie. Vandaag altijd 00; ff is verboden. ff
trace-id 32 16 Identificeert de hele trace van begin tot eind. Louter nullen
parent-id 16 8 Identificeert de aanroepende span, niet het verzoek. Louter nullen
trace-flags 2 1 Een veld van 8 bits — lees het bit voor bit, nooit als boolean. —

trace-flags-waarden: 00, 01, 02 en 03 uitgelegd

trace-flags-waarden: 00, 01, 02 en 03 uitgelegd
Hex Binair sampled random-trace-id Betekenis
00 00000000 0 0 Upstream koos ervoor niet te samplen — kijk naar de aanroeper, niet naar je eigen service.
01 00000001 1 0 Normaal vastgelegd. Dit zie je het vaakst.
02 00000010 0 1 Willekeurige trace-ID verklaard, maar niet gesampled.
03 00000011 1 1 Vastgelegd, en de trace-ID is als uniform willekeurig verklaard.

bit 0 — De aanroeper heeft deze trace vastgelegd. Gewist betekent dat hij dat bewust niet deed.

bit 1 — Level 2: de 7 meest rechtse bytes van de trace-ID zijn uniform willekeurig.

bit 2-7 — Gereserveerd. Moet worden genegeerd en bij uitgaande verzoeken gewist.

Veldbreedtes, ongeldige waarden, de semantiek van de vlaggenbits en de tracestate-limieten op deze pagina zijn gecontroleerd aan de hand van de gepubliceerde specificatietekst, niet aan de hand van samenvattingen van derden. — Go Tools Engineering Team · Jul 22, 2026

Rechtstreeks gebouwd op de W3C Trace Context-aanbeveling en de candidate recommendation van Level 2, met de parser gedekt door unittests voor elke geldige en ongeldige vorm die de specificatie noemt.

Wat is de traceparent-header?

traceparent is de HTTP-header die een gedistribueerde trace van de ene service naar de volgende draagt. Voor de standaardisatie propageerde elke tracingleverancier context in een eigen header, waardoor een verzoek dat systemen overstak zijn identiteit verloor op de grens. De W3C Trace Context-specificatie loste dat op met één bewust klein formaat: version-trace-id-parent-id-trace-flags, vier hexadecimale velden verbonden door streepjes, samen 55 tekens in de huidige versie.

Elk veld doet één ding. De version is vandaag altijd 00, en ff is ronduit verboden. De trace-id is 16 bytes en identificeert het hele verzoek van begin tot eind — hij blijft bij elke hop gelijk. De parent-id is 8 bytes en identificeert de span van de directe aanroeper, dus anders dan de trace-id verandert hij bij elke hop. Het byte trace-flags is waar de meeste verwarring zit: het lijkt een boolean omdat 01 verreweg de meest voorkomende waarde is, maar het zijn acht bits. Bit 0 is sampled. Bit 1, toegevoegd in Trace Context Level 2, is random-trace-id en stelt dat de zeven meest rechtse bytes van de trace-ID uniform willekeurig zijn, zodat downstream-systemen erop mogen samplen of sharden. De overige zes bits zijn gereserveerd, en precies daarom moet het veld met een bitsgewijze AND worden gelezen in plaats van op gelijkheid vergeleken.

Een bijbehorende header, tracestate, draagt daarnaast leverancierspecifieke sleutel-waardeparen mee, met een plafond van 32 members. Dat plafond verklaart een raadselachtig symptoom: leveranciersdata die aan de edge aanwezig is en een paar hops later verdwenen, omdat tussenliggende systemen entries begonnen te laten vallen zodra de lijst over de limiet ging. De header werd pas echt universeel toen OpenTelemetry hem overnam, en deze pagina decodeert het geheel — velden, bits, tracestate-members en de equivalente identifiers voor andere propagatieformaten — zonder ook maar iets ergens naartoe te sturen.

# The header as it travels on the wire
traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01
tracestate:  rojo=00f067aa0ba902b7,congo=t61rcWkgMzE

# Read the four fields apart
#   version     00
#   trace-id    4bf92f3577b34da6a3ce929d0e0e4736   (16 bytes, whole request)
#   parent-id   00f067aa0ba902b7                   (8 bytes, calling span)
#   trace-flags 01                                 (bit 0 set = sampled)

# Send one yourself
$ curl -H 'traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01' \
       https://example.com/api

Functies

Elk veld apart en kopieerbaar

Version, trace-id, parent-id en trace-flags krijgen elk een eigen regel en een eigen kopieerknop, zodat een trace-ID van 32 tekens in een query zetten één klik kost in plaats van zorgvuldig slepen.

trace-flags gelezen als acht bits

Het vlaggenbyte wordt uitgeklapt naar alle acht posities met hun hexadecimale maskers. Bit 0 is sampled, bit 1 is de Level 2-vlag random-trace-id, en de gereserveerde bits worden getoond in plaats van stilzwijgend weggegooid.

Conversie naar Datadog, X-Ray en B3

De onderste 64 bits als decimale Datadog trace-ID, de bovenste 64 bits als de tag die meereist, de X-Ray-vorm 1-{8}-{24}, en zowel de single- als de multi-header-variant van B3 — allemaal berekend met BigInt, zodat er niets overloopt.

Diagnoses, niet alleen oordelen

Een trace-ID van louter nullen wordt uitgelegd als tracing die nooit is geïnitialiseerd; een gewist sampled-bit als een beslissing die upstream is genomen. Weten welke van de twee je voor je hebt, is meestal de hele debugsessie.

tracestate met het plafond van 32 members

Members worden getoond met validatie van sleutel en waarde per stuk en een lopende telling tegen de limiet uit de specificatie — de limiet die verklaart waarom leveranciersdata een paar hops verderop verdwijnt.

Er verlaat niets je browser

Het parsen is gewone stringbewerking en BigInt-rekenwerk, zonder dependencies en zonder netwerkaanroepen, geverifieerd door een geautomatiseerde contracttest bij elke build. Link kopiëren gebruikt het URL-fragment, dat nooit wordt verzonden.

traceparent-voorbeelden, gedecodeerd

Het voorbeeld uit de specificatie zelf, gedecodeerd

00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01
version 00 · trace-id 4bf92f3577b34da6a3ce929d0e0e4736 · parent-id 00f067aa0ba902b7 · trace-flags 01 (sampled)

Vier velden gescheiden door streepjes, samen 55 tekens bij version 00. De trace-id identificeert het hele verzoek terwijl het elke service passeert; de parent-id — vaak span-ID genoemd — identificeert alleen de directe aanroeper, en daarom verandert die bij elke hop terwijl de trace-id gelijk blijft. De 01 aan het eind is een volledig byte, geen boolean: bit 0 staat aan, dus de aanroeper heeft deze trace vastgelegd.

trace-flags 00 — de aanroeper koos ervoor niets vast te leggen

00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00
Geldige header · sampled-bit gewist

Deze header is volkomen geldig, en dat is precies het punt. Een gewist sampled-bit is een instructie van upstream, geen defect in jouw service: wie jou aanriep heeft de eigen sampler geraadpleegd en besloot niets vast te leggen. Hier ontbrekende spans zoeken in je eigen configuratie kost uren. De juiste vraag is welke service jou aanroept, een parent-span meestuurt en besluit de trace niet te samplen.

Een trace-ID van louter nullen betekent dat tracing nooit begon

00-00000000000000000000000000000000-00f067aa0ba902b7-01
Ongeldig — trace-id bestaat uit louter nullen

De specificatie verklaart een trace-id van louter nullen ongeldig en eist dat de hele traceparent wordt genegeerd. Het is nuttig te weten wat dat in de praktijk aangeeft: niet "een trace die nog geen data heeft", maar een SDK die nooit is geïnitialiseerd, of middleware die een placeholder-header injecteert. Dezelfde regel geldt voor een parent-id van louter nullen.

Dezelfde trace-ID in het formaat van Datadog

00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01
x-datadog-trace-id 11803532876627986230 · _dd.p.tid 4bf92f3577b34da6

Datadog draagt de onderste 64 bits van een 128-bits trace-ID als decimale string, en de bovenste 64 bits hexadecimaal in een aparte tag. Voer je de volledige 128-bits waarde als decimaal in, dan krijg je een getal dat nergens op matcht — precies daarom duikt deze conversie keer op keer op in de issue trackers van tracers. De onderste helft is hier a3ce929d0e0e4736, en 64 bits gaan verder dan een JavaScript-number aankan, dus deze pagina rekent met BigInt.

Zo gebruik je de traceparent-decoder

  1. 1

    Plak de traceparent-header

    Zet de ruwe headerwaarde erin — bijvoorbeeld 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01. Decoderen gebeurt terwijl je typt; er is geen knop om in te drukken.

  2. 2

    Lees de vier velden apart

    Version, trace-id, parent-id en trace-flags krijgen elk een eigen regel met kopieerknop, zodat je alleen de trace-ID in een query zet zonder 32 tekens met de hand te selecteren.

  3. 3

    Controleer de vlaggen bit voor bit

    Het trace-flags-byte wordt uitgeklapt naar alle acht bits met hun maskers, zodat sampled en de Level 2-vlag random-trace-id afzonderlijk zichtbaar zijn in plaats van verstopt in een waarde van twee tekens.

  4. 4

    Converteer naar het formaat van je backend

    Datadog, AWS X-Ray en beide B3-vormen worden eronder gegenereerd, inclusief de decimale trace-ID van de onderste 64 bits die Datadog verwacht en de tag met de bovenste 64 bits die ernaast meereist.

  5. 5

    Voeg tracestate toe en deel het resultaat

    Plak een tracestate-header om de members te tonen met validatie per member en een telling tegen de limiet van 32, en gebruik daarna Link kopiëren om de exacte toestand vast te leggen in een URL die je in een ticket kunt plakken.

Veelgemaakte fouten met traceparent

Het hele vlaggenbyte met 01 vergelijken

Dit behandelt een veld van acht bits als een opsomming. Een trace die gesampled is en ook de Level 2-vlag random-trace-id draagt, heeft flags 03, en de gelijkheidscontrole rapporteert hem als niet gesampled.

✗ Fout 
if (traceFlags === 0x01) { record(); }
✓ Correct 
if (traceFlags & 0x01) { record(); }

Alle 128 bits naar één decimaal getal omzetten

Datadog verwacht de onderste 64 bits decimaal en de bovenste 64 bits hexadecimaal in een aparte tag. De volledige waarde als één decimaal getal doorgeven levert een identifier op die nergens op matcht.

✗ Fout 
x-datadog-trace-id: 100985939111033328018442752961257817910
✓ Correct 
x-datadog-trace-id: 11803532876627986230
x-datadog-tags: _dd.p.tid=4bf92f3577b34da6

Elke versie afwijzen die niet 00 is

De specificatie vraagt parsers te lezen wat ze van een hogere versie herkennen en velden aan het eind te tolereren. Botweg afwijzen start de trace opnieuw en verbreekt de koppeling op de grens.

✗ Fout 
if (version !== '00') throw new Error('bad traceparent');
✓ Correct 
if (version !== '00' && header.length >= 55) { /* parse the known prefix */ }

Hexadecimaal in hoofdletters versturen

De grammatica staat alleen kleine letters toe. Een trace-ID in hoofdletters draagt de juiste waarde en wordt toch afgewezen door een conforme ontvanger, wat het een bijzonder vervelende bug maakt om met het blote oog te zien.

✗ Fout 
traceparent: 00-4BF92F3577B34DA6A3CE929D0E0E4736-00F067AA0BA902B7-01
✓ Correct 
traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01

Wat je met de traceparent-decoder kunt doen

Uitzoeken waarom een trace geen spans heeft
Plak de binnenkomende header en lees het sampled-bit. Is het gewist, dan zou de trace sowieso niet worden vastgelegd en ligt het antwoord bij de aanroeper, niet bij jouw instrumentatie — een onderscheid dat veel tijd bespaart die anders in je eigen samplerconfiguratie gaat zitten.
Een trace vinden die je backend niet vindt
Als een trace-ID uit je applicatielogs niets oplevert in Datadog, is het formaat meestal de boosdoener. Converteer hem hier om de decimale identifier van de onderste 64 bits te zien die de API verwacht, samen met de tag van de bovenste 64 bits die mee moet.
Headers controleren die je gateway injecteert
Proxies en service meshes genereren trace-context bij binnenkomst. Plak wat er werkelijk aankwam om lengte, kleine letters in hex en niet-nulwaarden te bevestigen voordat je aanneemt dat de fout verderop ligt.
Een productietrace met de hand reproduceren
Neem een header uit een echt verzoek en speel hem opnieuw af tegen een staging-endpoint om dezelfde trace te volgen. Bouw het verzoek met de curl-commandobouwer en plak de header er rechtstreeks in.
Trace-context uitleggen aan een team
De tabellen met veldanatomie en trace-flags op deze pagina zijn statisch naslagmateriaal om naar te wijzen, en de voorbeeldknoppen demonstreren elk foutgeval zonder dat iemand een service hoeft te slopen om er een te maken.

Hoe de W3C Trace Context-validator werkt

De grammatica met vier velden
version "-" trace-id "-" parent-id "-" trace-flags, alles in kleine letters hexadecimaal. Version is 2 cijfers, trace-id 32, parent-id 16 en trace-flags 2 — 52 hexcijfers plus 3 streepjes, precies 55 tekens voor version 00. Hoofdletters in hex maken de header ongeldig ook al ziet de waarde er goed uit, en zowel een trace-id als een parent-id van louter nullen is expliciet ongeldig in plaats van leeg.
trace-flags is een bitveld
Bit 0 (masker 0x01) is sampled: aan betekent dat de aanroeper tracedata vastgelegd kan hebben. Bit 1 (masker 0x02), geïntroduceerd in Level 2, is random-trace-id: staat het aan, dan moeten minstens de 7 meest rechtse bytes van de trace-id willekeurig zijn gekozen met een uniforme verdeling, waardoor downstream-systemen erop kunnen samplen of sharden. Bits 2 tot en met 7 zijn gereserveerd en moeten bij ontvangst worden genegeerd en bij uitgaande verzoeken worden gewist. Omdat gereserveerde bits aanwezig kunnen zijn, moet het veld met een bitsgewijze AND worden getest — een gelijkheidscontrole tegen 0x01 rapporteert een gesamplede trace die ook een gereserveerd bit draagt verkeerd.
Voorwaartse compatibiliteit met toekomstige versies
Version is vandaag 00 en ff is verboden, maar een parser die al het andere afwijst, zit fout. De specificatie vraagt ontvangers te proberen te parsen wanneer de versie hoger is en de header minstens zo lang als het bekende formaat, waarbij ze de velden lezen die ze herkennen en extra data aan het eind tolereren, in plaats van de trace opnieuw te starten. Deze decoder volgt die regel: een toekomstige versie wordt succesvol geparseerd en gemarkeerd als waarschuwing, niet als fout.
tracestate-limieten die in productie pijn doen
Maximaal 32 list-members — een harde grammaticale grens: is de lijst langer, dan is de header ongeldig en gooien ontvangers hem weg. Elke sleutel is maximaal 256 tekens en begint met een kleine letter of cijfer; sinds Level 2 is de @ een gewoon sleutelteken en geen tenant-scheidingsteken meer. Elke waarde is 1 tot 256 printbare ASCII-tekens, nooit met een komma of een isgelijkteken. Dubbele sleutels zijn ongeldig, maar lege list-members zijn uitdrukkelijk toegestaan — de komma die achterblijft wanneer een tussenliggend systeem een entry verwijdert, levert nog steeds een geldige header op. Los daarvan: leveranciers zouden minstens 512 tekens van de gecombineerde header moeten doorgeven; moeten ze snoeien om binnen dat budget te blijven, dan horen entries langer dan 128 tekens als eerste te sneuvelen — en daarom verdwijnt de data van een breedsprakige leverancier eerder dan die van een bondige.

Best practices voor Trace Context

Test vlaggen met een bitsgewijze AND
Schrijf flags & 0x01 in plaats van flags == 0x01. Zes van de acht bits zijn gereserveerd voor toekomstig gebruik, en een gelijkheidscontrole gaat gesamplede traces verkeerd rapporteren zodra een van die bits in het wild opduikt.
Behandel een ID van louter nullen als een kapotte pipeline
Het is geen lege waarde die je moet tolereren. Wijs de header af en ga op zoek naar het onderdeel dat zijn tracer niet heeft geïnitialiseerd of een placeholder injecteert.
Kijk upstream als het sampled-bit gewist is
Parent-based samplers geven de beslissing van de aanroeper door. Ontbreken er traces, stel dan eerst vast welke service jou een parent-span stuurt met sampling uit voordat je je eigen configuratie doorspit.
Houd tracestate kort
Het plafond van 32 members is een harde grammaticale grens — overschrijd je het, dan is de header ongeldig. Los daarvan is alleen 512 tekens van de gecombineerde header gegarandeerd doorgegeven, en bij snoeien sneuvelen entries boven de 128 tekens het eerst. Wat een lange aanroepketen moet overleven, hoort niet in tracestate.
Log een trace-ID nooit als JavaScript-number
Een 128-bits trace-ID en zelfs een 64-bits Datadog-identifier gaan allebei voorbij Number.MAX_SAFE_INTEGER. Houd ze als strings en converteer met BigInt wanneer je moet rekenen, anders vermink je stilletjes de laatste cijfers.

Veelgestelde vragen over de traceparent-decoder

Wat is de traceparent-header?
Het is de ene HTTP-header die een gedistribueerde trace over servicegrenzen heen meedraagt, gestandaardiseerd door het W3C zodat tools van verschillende leveranciers hetzelfde verzoek kunnen volgen. Hij bevat vier velden gescheiden door streepjes — version, trace-id, parent-id en trace-flags — en is in de huidige versie altijd precies 55 tekens lang. Elk serieus tracingsysteem spreekt hem inmiddels, en dat is wat een verzoek traceerbaar maakt van een edge-proxy tot door een stuk of zes services zonder dat elke hop het over één leverancier eens hoeft te zijn. De volledige grammatica staat in de W3C Trace Context-aanbeveling.
Wat betekent traceparent met trace-flags 00?
Het betekent dat de aanroeper expliciet heeft besloten dat deze trace niet vastgelegd moet worden. Het sampled-bit is bit 0 van het trace-flags-byte; is het gewist, dan heeft een upstream sampler het verzoek beoordeeld en ervoor gekozen het niet vast te leggen. Dit is de meest verkeerd gelezen waarde in de header, omdat hij op een storing lijkt terwijl het een beslissing is. Ontbreken er spans, dan is de nuttige vraag niet wat er in jouw service kapot is, maar welke upstream service jou een parent-span stuurt met sampling uit — een parent-based sampler geeft die keuze vervolgens door aan alles wat downstream ligt.
Wat is het verschil tussen trace-flags 01, 02 en 03?
trace-flags is een veld van acht bits, dus dit zijn combinaties en geen opsomming. 01 zet alleen bit 0: de trace is gesampled. 02 zet alleen bit 1: de Level 2-vlag random-trace-id, die stelt dat minstens de zeven meest rechtse bytes van de trace-ID uniform willekeurig zijn gegenereerd — downstream-systemen kunnen dan veilig op die bytes samplen of sharden. 03 zet beide. Omdat het een bitveld is, moet je het testen met een bitsgewijze AND; het hele byte met 01 vergelijken rapporteert elke trace verkeerd die ook een gereserveerd bit draagt, en juist die gereserveerde bits gaan toekomstige versies gebruiken.
Waarom bestaat mijn trace-ID uit louter nullen?
Omdat tracing nooit is geïnitialiseerd, niet omdat de trace bestaat maar geen data heeft. De specificatie noemt een trace-id van louter nullen een ongeldige waarde en draagt ontvangers op de hele header te negeren, dus niets downstream zal eraan koppelen. In de praktijk komt het van een SDK die niet is opgestart, van een handmatig samengestelde header, of van middleware die een placeholder invult toen er geen echte context was. De parent-id van louter nullen, 0000000000000000, is om dezelfde reden ongeldig.
Hoe converteer ik een W3C trace-ID naar een Datadog trace-ID?
Neem de onderste 64 bits — de 16 hexcijfers rechts — en schrijf ze als decimale string; dat is wat in x-datadog-trace-id hoort. De bovenste 64 bits blijven hexadecimaal en reizen apart mee in de tag _dd.p.tid. De parent-id gaat in zijn geheel naar decimaal. Dit omdraaien, of alle 128 bits naar één decimaal getal omzetten, levert een identifier op die nergens in de UI op matcht, en daarom komt het steeds terug in de issue trackers van tracers. Deze pagina doet de splitsing voor je; wil je de onderliggende hexadecimale rekenkunde op willekeurige waarden verkennen, dan is de talstelsel-omrekenaar er voor algemene basisconversie, terwijl deze pagina specifiek blijft voor trace-identifiers.
Bevat een traceparent een timestamp?
Nee — en daar gaan mensen de mist in, omdat sommige andere trace-identifiers dat wel doen. Een W3C trace-id bestaat uit 16 ondoorzichtige bytes zonder ingebedde tijd. Een AWS X-Ray trace-ID heeft daarentegen de vorm 1-{8 hex}-{24 hex}, waarbij de eerste acht hexcijfers het aanmaakmoment in epoch-seconden zijn; converteren tussen beide formaten verplaatst de bytes, maar kan geen timestamp verzinnen die er nooit was. Heb je identifiers nodig die wel op tijd sorteren, dan zijn UUIDv7 en ULID daarvoor bedoeld.
Wordt de header die ik hier plak ergens geüpload?
Nee. Elk veld wordt lokaal in je browser geparseerd met gewone stringbewerkingen en BigInt-rekenwerk — geen serveraanroep, geen logging van wat je typt, en niets wordt bewaard. Dat weegt hier zwaarder dan bij de meeste tools, want een traceparent uit een productieverzoek identificeert echt verkeer in je observability-backend. Je hoeft ons niet op ons woord te geloven: open de developer tools van je browser en kijk hoe het Network-paneel stil blijft terwijl je typt, of verbreek de netwerkverbinding volledig en decodeer gewoon door. Het uitblijven van externe verzoeken wordt bovendien afgedwongen door een geautomatiseerde contracttest die bij elke build draait, dus het kan niet stilletjes terugvallen.
Werkt deze decoder offline?
Ja. De pagina is statisch en de decoder is een paar kilobyte JavaScript zonder dependencies, dus zodra hij geladen is kun je offline gaan — of vliegtuigmodus aanzetten voordat je iets plakt — en werkt hij precies hetzelfde. Werk je met headers uit een gevoelige omgeving, dan is dat de volgorde die de moeite waard is: pagina laden, verbinding verbreken, dan plakken. De knop Link kopiëren codeert de toestand in het URL-fragment na het #-teken, en fragmenten worden evenmin ooit naar een server verstuurd.

Gerelateerde tools

Alle tools bekijken →

cURL-commando generator en builder

Web & API

Bouw curl-commando's in je browser — stel methode, headers, auth en body in en krijg direct een kopieerbaar commando. Presets voor Bearer, POST JSON en bestandsupload. Gratis, privé, geen registratie.

htpasswd-generator — bcrypt, Apache MD5 (apr1) & Basic Auth

Web & API

Genereer htpasswd-vermeldingen met bcrypt, Apache MD5 (apr1), SHA-1 en meer. Krijg direct kopieerbare Apache-, nginx- en Docker-configuratie. 100% in je browser — niets wordt geüpload.

Open Graph- & Metatag-generator

Web & API

Genereer Open Graph-, Twitter Card- en SEO-metatags met een live preview voor Google, Facebook en X. 100% gratis, in de browser, geen registratie — code kopiëren en plakken.

nginx location tester — waarom dat blok wint

Web & API

Zie welk nginx location-blok wint — en waarom elk ander blok verloor. Gratis tester voor location-matching met =, ^~, ~ en ~*, volledig in je browser.

AES-ontsleutelingstool — OpenSSL- & CryptoJS-compatibel

Beveiligingstools

Ontsleutel AES online — GCM/CBC/CTR, wachtwoordzin of ruwe sleutel, detecteert automatisch het OpenSSL- & CryptoJS-formaat "U2FsdGVkX1". 100% in de browser, sleutels verlaten de pagina nooit.

AES-versleutelingstool — GCM, CBC & CTR

Beveiligingstools

Gratis AES-versleuteling online — AES-128/192/256, GCM/CBC/CTR, wachtwoordzin (PBKDF2) of ruwe sleutel. Draait 100% in je browser; niets wordt geüpload.