Der Server-Timing Header übermittelt selbst erfasste Backend-Kennzahlen mit einer HTTP-Antwort. Du kannst sie in den Browser-DevTools der jeweiligen Anfrage zuordnen oder über die Performance API auslesen. Voraussetzung ist, dass die Anwendung oder eine andere antwortgebende Komponente die Werte erfasst und ausgibt. Der Header ist kein automatischer Profiler: Erst dokumentierte Messgrenzen zeigen, welche Arbeit eine Dauer umfasst. Überschneidungen, Netzwerkwege und Cache-Antworten können die Interpretation verändern.
Was Server-Timing sichtbar macht
Eine langsame Seite kann Zeit im Browser, auf dem Netzwerkweg oder bei der Verarbeitung auf dem Server verlieren. Der Server-Timing-Header verbindet diese Sichtweisen: Er überträgt Kennzahlen, die eine beteiligte Serverkomponente selbst erfasst hat, zusammen mit einer HTTP-Antwort. Der Browser kann sie anschließend der jeweiligen Anfrage zuordnen und anzeigen.
Dazu muss beispielsweise die Anwendung die Dauer einer Datenbankoperation messen und den Wert in den Antwortheader schreiben. Auch ein Proxy oder eine andere antwortgebende Komponente kann Metriken beitragen. Ohne eine solche Instrumentierung kann der Browser nachträglich nicht ermitteln, wie lange einzelne serverseitige Arbeitsschritte gedauert haben.
Der Header ist damit ein Transportformat, kein automatischer Profiler. Er legt nicht fest, welche internen Funktionen untersucht werden oder wie detailliert eine Anwendung messen muss. Welche Kennzahlen erscheinen, hängt davon ab, was die verantwortliche Komponente erfasst und zur Ausgabe freigibt.
Für die Backend Performance ist das hilfreich, weil ein selbst gemessener Abschnitt unmittelbar neben den Informationen zur Browseranfrage sichtbar wird. Ein hoher Wert ist zunächst ein Ansatzpunkt für weitere Untersuchungen, aber noch kein Beweis dafür, warum eine Seite langsam ist. Die Kennzahl allein erklärt weder ihre Ursache noch alle anderen Anteile der Web Performance.
Für die praktische Nutzung brauchst du daher Zugriff auf die Anwendung oder eine andere Komponente, die die Antwort beeinflussen kann. Wenn bereits Metriken mitgeliefert werden, kannst du sie dagegen im Browser untersuchen, ohne selbst die Serverkonfiguration zu ändern. Auch dann solltest du klären, woher die Werte stammen und was sie tatsächlich umfassen.
Metriken und Header-Syntax verstehen
Eine HTTP-Antwort kann eine oder mehrere Server-Timing-Headerzeilen enthalten. Innerhalb einer Zeile trennen Kommas die einzelnen Metriken; ein Semikolon leitet jeweils einen Parameter ein. Jede Metrik braucht einen Namen, während Dauer und Beschreibung optional sind. Eine gemeldete Dauer steht im Parameter dur und wird in Millisekunden angegeben.
Das folgende Beispiel zeigt eine HTTP-Antwortheaderzeile mit zwei Metriken. Die Zahlen sind frei gewählt und keine Messung; die Zeile ist lediglich ein Syntaxbeispiel und setzt keine bestimmte Anwendung oder Serverkonfiguration voraus.
Hier bezeichnet db eine Metrik mit Dauer und Beschreibung; render hat eine Dauer, aber keine Beschreibung. Die Angaben nach desc dienen der Erläuterung. Sie ersetzen keine Dokumentation darüber, wann die jeweilige Messung beginnt und endet.
| Bestandteil | Bedeutung | Pflichtstatus | Beispiel |
|---|---|---|---|
| Name | Bezeichnet die Metrik | Erforderlich | db |
| dur | Dauer in Millisekunden | Optional | dur=42.5 |
| desc | Beschreibung der Metrik | Optional | desc="Datenbank" |
Ein Name wie db verrät für sich genommen weder die Messgrenzen noch die Messmethode. Er könnte eine einzelne Abfrage, mehrere zusammengezählte Abfragen oder einen anders definierten Datenbankabschnitt bezeichnen. Erst die Dokumentation der Instrumentierung macht verständlich, welche Arbeit tatsächlich im Wert enthalten ist.
Für aussagekräftige Vergleiche solltest du deshalb zu jeder Metrik Start- und Endpunkt festhalten und beschreiben, ob sie weitere Teiloperationen einschließt. Bleibt etwa der Name gleich, während die Anwendung später zusätzliche Abfragen in die Zeit einrechnet, sind alte und neue Werte nicht ohne Weiteres vergleichbar. Die Syntax allein weist auf eine solche Änderung nicht hin.
Backend-Dauer und Browser-Wartezeit abgrenzen
Die im Browser sichtbare Wartezeit und eine gemeldete Backend-Dauer beschreiben nicht zwangsläufig dieselbe Zeitspanne. Eine Metrik kann nur einen bewusst ausgewählten Abschnitt der Verarbeitung erfassen, während die Browseransicht weitere Teile des Anfrage- und Antwortwegs abbildet. Ähnliche oder unterschiedliche Zahlen bedeuten daher nicht automatisch, dass beide Messungen einander bestätigen oder widersprechen.
Zwischen Browser und Anwendung können etwa Netzwerkwege und Proxys liegen. Auch Warteschlangen oder Arbeitsschritte innerhalb des Backends bleiben möglicherweise außerhalb der gesetzten Messpunkte. Wenn der Browser länger wartet als eine gemeldete Datenbankoperation dauert, lässt sich die Differenz deshalb nicht allein aus dieser einen Kennzahl einer bestimmten Ursache zuordnen.
Umgekehrt können sich Server-Timing-Metriken überlappen oder ineinander verschachtelt sein. Misst eine Gesamtmetrik die Verarbeitung einer Anfrage einschließlich der Datenbankoperation, steckt deren Dauer bereits im Gesamtwert. Addierst du beide Zahlen, zählst du diesen Abschnitt doppelt; bei parallel ausgeführten Operationen kann auch die Summe ihrer Einzeldauern größer sein als die verstrichene Zeit.
Der Header bildet daher keinen automatisch vollständigen Wasserfall der Verarbeitung. Er übermittelt benannte Kennzahlen, aber die Namen und Dauern allein legen weder eine zeitliche Reihenfolge noch Beziehungen zwischen den Abschnitten fest. Für die Interpretation musst du wissen, ob die Instrumentierung getrennte, verschachtelte oder gleichzeitig laufende Arbeiten erfasst.
Bevor du eine Optimierung ableitest, halte die Messgrenzen und Bedingungen der betrachteten Anfrage fest. Wiederhole anschließend vergleichbare Anfragen und prüfe, ob sich das Muster unter denselben Bedingungen zeigt. So unterscheidest du einen einzelnen auffälligen Wert besser von einem wiederkehrenden Hinweis, ohne aus der Metrik allein eine Ursache zu behaupten.
HTML-Antwort in DevTools prüfen
Für eine dynamische HTML-Seite kann die Anwendung zwei getrennte Arbeitsschritte erfassen: eine Datenbankoperation und die anschließende Erstellung des HTML. Die Messung muss in der Anwendung oder einer anderen antwortgebenden Komponente eingerichtet sein. DevTools zeigt die gelieferten Werte an, ermittelt die internen Laufzeiten aber nicht selbst.
Definiere für db den Beginn unmittelbar vor dem Aufruf einer bestimmten Datenbankoperation und das Ende, sobald deren Ergebnis in der Anwendung vorliegt. Für render beginnt die Zeit unmittelbar vor der HTML-Erstellung und endet, sobald das fertige HTML für die Antwort bereitsteht. Dokumentiere, ob beispielsweise das Laden von Vorlagen darin enthalten ist.
Angenommen, beide Schritte sind vor dem Senden der Antwortheader abgeschlossen: Dann könnte die Antwort Server-Timing: db;dur=42.5, render;dur=18.0 enthalten. Die Zahlen sind frei gewählt und keine Messung. Erst die dokumentierten Start- und Endpunkte machen sie für eine spätere Untersuchung sinnvoll vergleichbar.
Öffne in Chrome die Entwicklerwerkzeuge und den Bereich Network. Lade die Seite neu, wähle in der Anfrageliste die Dokumentanfrage und prüfe unter Headers den empfangenen Rohheader. Unter Timing kannst du anschließend die Darstellung der gemeldeten Server-Timing-Werte ansehen; die genaue Darstellung kann sich je nach Browser unterscheiden.
Ein auffälliger Einzelwert ist ein Ansatzpunkt, kein Nachweis für eine allgemeine Ursache. Wiederhole vergleichbare Anfragen und halte etwa verwendete Seite, Cache-Zustand und Änderungen an der Anwendung fest. So kannst du besser erkennen, ob sich ein Muster wiederholt oder ob eine einzelne Antwort aus dem Rahmen fällt.
API-Zeiten ohne Doppelzählung lesen
Bei einer API kann die Anwendung neben der gesamten Verarbeitung auch das Warten auf einen externen Dienst erfassen. Entscheidend ist dabei die Messgrenze: Beginnt die Gesamtzeit beim Eintritt in den API-Handler und endet sie, wenn dessen Antwort zur Ausgabe bereitsteht, kann der externe Aufruf vollständig darin enthalten sein.
Im folgenden frei gewählten Beispiel beginnt die externe Dauer unmittelbar vor dem Absenden der Anfrage an den Dienst und endet, sobald dessen Antwort in der Anwendung vorliegt. Die Werte dienen nur der Rechnung und sind keine Messung. Die Tabelle beschreibt ausdrücklich verschachtelte Zeitspannen, nicht zwei unabhängige Arbeitspakete.
| Metrik | Messgrenzen im Beispiel | Dauer |
|---|---|---|
| Gesamtverarbeitung | Eintritt in den Handler bis Antwort bereitsteht | 120 ms |
| Externer Aufruf | Absenden der Anfrage bis Antwort des Dienstes vorliegt | 80 ms |
Die Rechnung 120 ms plus 80 ms ergibt zwar 200 ms, wäre hier aber eine Doppelzählung: Die 80 ms liegen bereits innerhalb der 120 ms. Rechnerisch bleiben 40 ms der Gesamtspanne außerhalb des externen Aufrufs. Der Header allein erklärt jedoch nicht, welche Arbeit oder Wartezeit diese übrige Spanne enthält.
Auch parallele Abhängigkeiten lassen sich nicht einfach zu einer verstrichenen Gesamtzeit addieren. Laufen etwa zwei Aufrufe gleichzeitig und dauern jeweils 80 ms, summieren sich ihre Einzeldauern auf 160 ms, obwohl ihre Zeitspannen weitgehend überlappen können. Ohne Information über Beginn und Ende lässt sich der tatsächliche Überlappungsgrad aus den Dauern allein nicht bestimmen.
Für die Frage, welcher Dienst welchen weiteren Aufruf ausgelöst hat, ergänzt verteiltes Tracing die Headerwerte. Server-Timing kann ausgewählte Dauern an die Browserantwort binden, beschreibt aber nicht von sich aus die vollständigen Kausalbeziehungen zwischen Diensten. Achte beim Vergleich darauf, dass Trace und Header dieselben Operationen und Grenzen meinen.
Server-Timing per JavaScript auslesen
Die Performance API macht vorhandene Server-Timing-Daten auch programmatisch zugänglich. Ein Navigationseintrag beschreibt das Laden des aktuellen Dokuments; seine Eigenschaft serverTiming enthält die dafür verfügbaren gemeldeten Metriken. Das ist eine andere Auswahl als ein Eintrag für eine nachgeladene Ressource oder einen API-Aufruf.
Führe das folgende JavaScript in der Browserkonsole auf der zu untersuchenden Seite aus. Es wählt den ersten vorhandenen Navigationseintrag und gibt dessen Server-Timing-Liste tabellarisch aus. Der Code liest nur bereits verfügbare Werte: Er ändert keine Serverkonfiguration und führt keinen Lasttest aus.
Ist kein Navigationseintrag vorhanden oder liefert er keine zugänglichen Metriken, zeigt das Beispiel eine leere Liste. Daraus folgt weder, dass die Seite schnell oder langsam ist, noch zwingend, dass der Server keine Instrumentierung besitzt. Prüfe zunächst den Antwortheader und ob der ausgewählte Eintrag tatsächlich die gewünschte Anfrage beschreibt.
Für eine nachgeladene Ressource brauchst du stattdessen den passenden Ressourceneintrag. Unter den Einträgen des Typs resource kannst du anhand des Namens die gesuchte Anfrage identifizieren und deren serverTiming-Eigenschaft betrachten. Bei wiederholten Aufrufen derselben Adresse musst du darauf achten, welchen konkreten Eintrag du vergleichst.
Bei originübergreifenden Ressourcen beeinflusst zusätzlich die passende Freigabe über Timing-Allow-Origin, ob die Performance API die Zeitinformationen verfügbar macht. Auch Browserunterstützung und die jeweilige Umgebung können die Ausgabe beeinflussen. Vergleiche daher eine leere Liste mit dem Rohheader, bevor du an der Anwendung Änderungen vornimmst.
Origin-Freigaben und sensible Angaben
Beim Zugriff über die Performance API ist die Origin der aufrufenden Seite entscheidend. Stammt eine Ressource von einer anderen Origin, muss deren Antwort mit Timing-Allow-Origin die aufrufende Origin passend freigeben, damit JavaScript die entsprechenden Timing-Informationen einschließlich Server-Timing auslesen kann. Eine CORS-Freigabe allein ersetzt diese zusätzliche Freigabe nicht.
Eine konkrete Origin begrenzt die Freigabe auf die angegebene Herkunft. Der Platzhalter * erlaubt dagegen grundsätzlich allen Origins, die betreffenden Timing-Informationen über die Performance API einzusehen. Wähle daher die engere Freigabe, wenn nur eine bekannte Anwendung die Werte benötigt, und prüfe sie an der tatsächlich ausgelieferten Ressourcenantwort.
Die Origin-Freigabe macht einen Antwortheader nicht vertraulich. Wer die HTTP-Antwort selbst erhält, kann ihren Inhalt grundsätzlich untersuchen. Veröffentliche deshalb weder Zugangsdaten oder personenbezogene Angaben noch interne Hostnamen in Metriknamen und Beschreibungen. Auch feingranulare Laufzeiten können Rückschlüsse auf interne Abläufe ermöglichen; gib nur Werte aus, deren Nutzen und Risiko du bewusst abgewogen hast.
Prüfe die Auswertung außerdem in den Browsern, die deine Anwendung unterstützen soll: Die Unterstützung einzelner Details und Anforderungen an sichere Kontexte können variieren. Für die allgemeine Absicherung von Antworten sind zusätzlich geeignete Sicherheitsheader für Webserver relevant; sie ersetzen aber weder die Prüfung der Timing-Freigabe noch die Entscheidung, welche Messwerte öffentlich sein dürfen.
Fehlende Werte und Cache-Effekte prüfen
Bleibt die Liste mit Server-Timing-Werten leer, beginne bei der konkreten Anfrage im Netzwerkbereich der DevTools. Prüfe unter Headers, ob die ausgelieferte Antwort überhaupt einen Server-Timing-Header enthält und welche Namen dort stehen. Fehlt er, untersuche die Instrumentierung und mögliche Änderungen durch zwischengeschaltete Komponenten, statt aus der leeren Liste auf die Geschwindigkeit zu schließen.
Ist der Rohheader vorhanden, kontrolliere als Nächstes den Performance-Eintrag: Der Navigationseintrag beschreibt das Laden des Dokuments, während ein API-Aufruf oder eine andere Ressource einen passenden Ressourceneintrag benötigt. Bei originübergreifenden Ressourcen prüfst du außerdem die Freigabe durch Timing-Allow-Origin sowie die Unterstützung im verwendeten Browser. Eine leere Liste beweist für sich weder fehlende Instrumentierung noch eine schnelle oder langsame Antwort.
Auch ein vorhandener Wert braucht Kontext. Ein CDN oder Proxy kann eigene Metriken beisteuern; zugleich kann eine Antwort samt Header aus einem Cache stammen. Dann beschreibt eine zuvor erzeugte Origin-Metrik nicht zwingend die Arbeit des Origin-Servers für die aktuelle Anfrage. Dokumentiere daher Cache-Status und Herkunft getrennt von der Dauer.
Prüfe am konkreten Aufbau, welche Komponente den Header setzt, weiterreicht oder verändert und wie sie mit gecachten Antworten umgeht. Vergleiche anschließend Anfragen mit bekanntem Cache-Zustand, soweit deine Infrastruktur das ermöglicht. Unterschiede zwischen diesen Antworten sind nützliche Hinweise, aber ohne Kenntnis der jeweiligen Messgrenzen noch kein Beweis für eine bestimmte Ursache.
Logs, Trailer und Werkzeugwahl
Server-Timing ergänzt andere Diagnosewege, statt sie zu ersetzen. Die passende Wahl hängt davon ab, ob du eine einzelne Browseranfrage verstehen, vorhandene Werte programmatisch erfassen oder Zusammenhänge über mehrere Dienste hinweg untersuchen möchtest. Die folgende Übersicht trennt den jeweiligen Erkenntnisgewinn von seinen Voraussetzungen und Grenzen.
| Werkzeug | Erkenntnis | Voraussetzung | Grenze |
|---|---|---|---|
| DevTools | Einzelne Anfrage und gemeldete Zeiten prüfen | Browseranfrage mit passenden Metriken | Keine automatische Ursachenanalyse |
| Performance API | Vorhandene Timing-Werte per JavaScript auslesen | Passender Eintrag und gegebenenfalls Origin-Freigabe | Kein vollständiger dienstübergreifender Ablauf |
| Serverlogs | Serverseitig protokollierte Zeiten auswerten | Passendes Logformat und Zugriff auf Logs | Messgrenzen und Einheiten müssen geprüft werden |
| Verteiltes Tracing | Zusammenhänge zwischen beteiligten Diensten untersuchen | Instrumentierung und Zuordnung der Traces | Zusätzlicher Betriebs- und Instrumentierungsaufwand |
Für eine erst nach Abschluss der Antwort feststehende Kennzahl kann ein Logeintrag geeigneter sein als ein regulärer Antwortheader. NGINX protokolliert beispielsweise request_time und upstream_response_time in Sekunden mit Millisekundenauflösung. Server-Timing verwendet dagegen Millisekunden: Ein Sekundenwert muss mit 1.000 multipliziert werden. Vor einem Vergleich prüfst du zusätzlich, wann die jeweilige Messung beginnt und endet.
Beim Streaming steht die Gesamtdauer des Antwortkörpers beim Versand regulärer Header möglicherweise noch nicht fest. Die Spezifikation erlaubt Server-Timing auch als HTTP-Trailer. Das ist jedoch keine universelle Lösung: Die Fetch API macht Trailer nicht zugänglich, und ihre Darstellung in Entwicklerwerkzeugen muss für den jeweiligen Browser gesondert geprüft werden.
Für belastbarere Vergleiche wiederholst du gleichartige Anfragen unter dokumentierten Bedingungen: Halte etwa Endpunkt, Cache-Zustand und relevante Änderungen am System fest. Betrachte mehrere Werte statt einer einzelnen Anfrage und untersuche auffällige Unterschiede mit Logs oder Traces weiter. So bleibt sichtbar, welche Beobachtung tatsächlich durch welche Messung gedeckt ist.
Eine browserbasierte Testumgebung kann beim Ausprobieren von Anwendungseinstellungen helfen, bildet aber nicht automatisch die Netzwerkwege und Serverdienste des späteren Betriebs ab. Das gilt auch für WordPress Playground im Browser. Aussagen über eine konkrete Hosting- und Backend-Konfiguration prüfst du zusätzlich in einer möglichst produktionsnahen Umgebung.
Quellen und fachlicher Stand
Recherche-Stand:
Recherchestand: 13. November 2026. Browserdarstellung und Unterstützung einzelner Funktionen können variieren; Beispiele enthalten keine eigenen Messungen.
https://www.w3.org/TR/server-timing/
https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/serverTiming
https://developer.chrome.com/docs/devtools/network?hl=en
https://developer.chrome.com/docs/devtools/performance/reference/
https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Timing-Allow-Origin
https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Server-Timing
https://docs.nginx.com/nginx/admin-guide/monitoring/logging/




