oktools

HAR File Viewer & Analyzer

Open a HAR file exported from Chrome, Firefox, Edge or Safari and see every request in a waterfall: status, size and timing, with headers, cookies, request and response bodies, and a timing breakdown for each, plus copy as curl. Filter to errors, API calls or one domain. Before sharing a HAR, download a sanitised copy with cookies, tokens and passwords removed. The file is read in your browser and never uploaded.

Open a HAR file

or drop one anywhere on this box

sample.har · https://shop.example.com/ · oktools.dev sample 1.0

11requests
123.4 KBtransferred
313.0 KBresources
1.24 suntil load
2errors
3domains

Requests

11 of 11 shown
301GET/shop.example.comDoc 312 B 75 ms
200GET/shop.example.comDoc 5.1 KB 196 ms
200GET/app.csscdn.example.netCSS 7.9 KB 127 ms
200GET/app.jscdn.example.netJS 60.4 KB 151 ms
200GET/inter.woff2cdn.example.netFont 47.2 KB 109 ms
200GET/hero.pngcdn.example.netImg 412 B 41 ms
404GET/favicon.icoshop.example.comOther 410 B 31 ms
200GET/v1/products?category=lamps&limit=3&api_key=pk_live_8f2a91c4api.example.comFetch/XHR 698 B 215 ms
200POST/v1/loginapi.example.comFetch/XHR 380 B 213 ms
500GET/v1/cartapi.example.comFetch/XHR 402 B 390 ms
304GET/app.csscdn.example.netCSS 190 B 21 ms

Share it safely

A HAR file contains your cookies, Authorization headers, API keys and anything you typed into forms — enough for someone to sign in as you. The sanitised copy replaces cookies, secret headers, and parameters and JSON keys such as password, token, api_key and secret with [REDACTED] — in URLs, headers that repeat a URL such as Referer and Location, and request and response bodies.

How it works

The file is parsed as JSON and read as HAR 1.2: log.entries holds one object per request, with the request, the response and its content, the timings and the moment it started. Every entry becomes a row — method, URL split into host and path, status, type, transfer size and time — and the earliest start in the file becomes zero, so each row’s position is how many milliseconds after that it began. The waterfall is drawn against the whole span, from the first start to the last finish, with each bar divided into coloured segments in proportion to its timing phases.

Browsers add fields of their own, and they are used when present. Chrome’s _resourceType decides whether a row is a document, Fetch/XHR, script or image, with the MIME type as the fallback; _transferSize is the bytes over the wire, falling back to the body and header sizes; a request with status 0 or an _error is marked failed; a 200 with no bytes transferred is marked as served from cache. Two timing details are tidied: HAR counts the TLS handshake inside connect, so it is subtracted out to give separate Connect and TLS phases, and the -1 a browser writes for a phase that did not happen becomes zero.

The sanitiser walks the same JSON and replaces rather than removes. Every cookie, headers such as Authorization, Cookie and X-API-Key, and any query parameter, form field or JSON key whose name looks like a secret — password, token, api_key, session, signature, code and so on — become [REDACTED], and credentials inside a URL are redacted wherever that URL is repeated: the HTTP/2 :path, the Referer, Location and Link headers, the redirect target, Chrome’s initiator and the page title. Base64-stored text bodies are decoded, redacted and re-encoded. The copy is written as a download from the same tab, and the file itself never leaves the browser.

Examples

Read a request’s timing phases

The sample’s /v1/products call. The file says connect: 55, which includes the 36 ms handshake, so the tab shows 19 ms of TCP and 36 ms of TLS. The long Wait is the server working; DNS, Connect and TLS being non-zero means this was the first request to api.example.com and no connection could be reused.

Entry in the HAR
{
  "startedDateTime": "2026-10-18T09:30:00.610Z",
  "time": 215,
  "timings": {
    "blocked": 1,
    "dns": 14,
    "connect": 55,
    "ssl": 36,
    "send": 0,
    "wait": 142,
    "receive": 3
  }
}
Timing tab
Blocked  1 ms  queued, waiting for a connection
DNS  14 ms  looking up the address
Connect  19 ms  opening the TCP connection
TLS  36 ms  the HTTPS handshake
Send  0 ms  uploading the request
Wait  142 ms  time to first byte: the server working
Receive  3 ms  downloading the response
Started 2026-10-18T09:30:00.610Z · 610 ms after the first request · 215 ms in total.

Copy a request as curl

The method, headers and body are written out as the browser sent them, quoted for a shell. HTTP/2 pseudo-headers such as :authority and the Content-Length header are left out, and an Accept-Encoding header becomes --compressed, since curl sets both itself.

Request in the HAR
{
  "method": "POST",
  "url": "https://api.example.com/v1/login",
  "headers": [
    { "name": "Content-Type", "value": "application/json" },
    { "name": "Origin", "value": "https://shop.example.com" }
  ],
  "postData": {
    "mimeType": "application/json",
    "text": "{\"email\":\"ada@example.com\",\"password\":\"correct horse battery staple\"}"
  }
}
curl
curl -X POST https://api.example.com/v1/login \
  -H 'Content-Type: application/json' \
  -H 'Origin: https://shop.example.com' \
  --data-raw '{"email":"ada@example.com","password":"correct horse battery staple"}'

Sanitise a request before sharing the file

Five values are replaced in this one request — the api_key in the URL and again in queryString, the Authorization and Cookie headers, and the cookie itself — while category=lamps is left alone. The success line after the download counts them: Downloaded pasted.sanitized.har with 5 values redacted.

Request in the HAR
"request": {
  "method": "GET",
  "url": "https://api.example.com/v1/products?category=lamps&api_key=pk_live_8f2a91c4",
  "headers": [
    { "name": "Authorization", "value": "Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiI0MiJ9.c2lnbmF0dXJl" },
    { "name": "Cookie", "value": "session=4f9c1e0b77aa" }
  ],
  "queryString": [
    { "name": "category", "value": "lamps" },
    { "name": "api_key", "value": "pk_live_8f2a91c4" }
  ],
  "cookies": [
    { "name": "session", "value": "4f9c1e0b77aa" }
  ]
}
Same request in the sanitised copy
"request": {
  "method": "GET",
  "url": "https://api.example.com/v1/products?category=lamps&api_key=%5BREDACTED%5D",
  "headers": [
    {
      "name": "Authorization",
      "value": "[REDACTED]"
    },
    {
      "name": "Cookie",
      "value": "[REDACTED]"
    }
  ],
  "queryString": [
    {
      "name": "category",
      "value": "lamps"
    },
    {
      "name": "api_key",
      "value": "[REDACTED]"
    }
  ],
  "cookies": [
    {
      "name": "session",
      "value": "[REDACTED]"
    }
  ]
}

Filter the sample to its errors

A request with a status of 400 or above, or one that failed before any status came back, counts as an error. The type buttons and the domain menu narrow the table the same way, and the columns sort by clicking their headings.

Filter
Errors only
Rows
404  GET  /favicon.ico  shop.example.com  Other  410 B  31 ms
500  GET  /v1/cart  api.example.com  Fetch/XHR  402 B  390 ms

Supported formats

  • HAR 1.2 from any browser or proxyChrome, Edge, Firefox and Safari exports, and files from Charles, Fiddler or mitmproxy. Chrome’s _resourceType, _transferSize and _initiator and Firefox’s _error are read when they are there.
  • Files up to 300 MB, or pasted JSONOpened with the button, dropped on the panel or pasted into the text box; a leading byte-order mark is ignored, and anything that is not JSON with log.entries is refused with a message saying so.
  • Bodies as the browser stored themText bodies shown as text and JSON pretty-printed; Base64 bodies decoded when they are text and previewed when they are images, SVG included; binary bodies left closed.
  • A sanitised copyA pretty-printed .sanitized.har download with the same entries and [REDACTED] in place of every secret, optionally with all response bodies removed as well.
  • curl commandsOne command per request, quoted for a POSIX shell, with --compressed standing in for the Accept-Encoding header.

Use cases

  • Find the slow requestSort by Time or read the waterfall: a long Wait segment is the server, long DNS or Connect the network, and a long Blocked segment too many requests queued for one host.
  • Debug an API call a user reportedAsk for a HAR, filter to Fetch/XHR and Errors only, open the 4xx or 5xx entry and read the request body and the response the server actually sent.
  • Attach a HAR to a support ticket safelyDownload the sanitised copy and send that: the session cookie and bearer token in the original would let anyone who reads the ticket sign in as you.
  • Replay a requestCopy it as curl to run in a terminal, or import that command into the Online API Client to change a field and resend it from the browser.
  • Audit what a page talks toThe domain menu lists every host a page contacted, and filtering by one shows what went there and how many bytes it took.

Limitations

  • It shows what the browser keptBodies exist only when the HAR was saved with content, cached responses have no transfer size, and Chrome drops cookies and some headers unless sensitive data is allowed in DevTools settings.
  • The sanitiser matches names, not valuesA token under a name such as x-session-id or auth_hdr is caught; one under a name like custom or payload is not, and neither is a secret inside free text. Read the copy before sending it.
  • No timeline of page eventsonLoad is reported, but DOMContentLoaded, paint timings and initiator chains are not drawn; the browser’s performance panel has those.
  • No comparing or mergingTwo HAR files cannot be shown side by side or combined; open them in two tabs.
  • No replay from the pageCopying as curl is the way to resend a request; the viewer itself never makes one, which is also what keeps the file private.

Frequently asked questions

What is a HAR file and how do I create one?

A HAR (HTTP Archive) file is a JSON record of every request a page made: URLs, headers, cookies, request and response bodies, and timings. In Chrome or Edge, open DevTools with F12, go to the Network tab, reload the page, then right-click any request and choose "Save all as HAR with content" — or use the download arrow at the top of the panel. In Firefox it is the gear menu in the Network tab, "Save All As HAR"; in Safari, Export in the Network tab. Support teams ask for one because it shows exactly what happened between a browser and a server.

How do I view a HAR file?

Open or drop it here. Every request is listed with its status, method, URL, type, size and time, with a waterfall showing when each started and how long it took. Filter by text, by type (Fetch/XHR, JS, CSS, images…), by domain, or to errors only; sort by any column. Selecting a request shows its request and response headers, query and form parameters, the request body, the response body formatted as JSON or previewed as an image, a breakdown of its timing from DNS to download, and its cookies — and copies it as a curl command.

Is it safe to share a HAR file?

Not as it comes. A HAR holds everything that crossed the network, which usually includes session cookies, Authorization headers with tokens, API keys in URLs and sometimes passwords in login requests — anyone with the file can often sign in as you. Before attaching one to a ticket, use "Download sanitised copy": it replaces cookies, secret headers, and secret-looking query parameters, form fields and JSON keys (password, token, api_key, secret…) with [REDACTED] — also where a URL repeats them, in the Referer and Location headers, the HTTP/2 :path and the #fragment an OAuth sign-in returns its token in — and can drop response bodies too. Check the result before sending, since a secret under an unusual name can still slip through.

Is my HAR file uploaded to a server?

No, and that is the point: the file is read and shown by JavaScript in your browser, and never leaves your device. That matters more for HAR files than almost anything else, since they carry live cookies and tokens. Many online HAR viewers upload the file to analyse it; this one does not, and you can confirm it by watching the network tab stay empty.

What do the timing phases mean?

Blocked is time spent queued in the browser, waiting for a free connection. DNS is looking up the domain's address, Connect is opening the TCP connection and TLS is the HTTPS handshake — all three are zero when a connection is reused. Send is uploading the request, Wait (time to first byte) is the server working on it, and Receive is downloading the response. A long Wait points at the server; long DNS or Connect at the network; long Blocked at too many requests to one host at once.

Why are some sizes or bodies missing?

Browsers leave out what they did not keep. Bodies are only included when the HAR was saved "with content", and even then large or binary responses may be omitted. A response served from the browser's cache has no transfer size, and a failed or blocked request (status 0) has no response at all. Chrome also hides cookies and some headers from HARs unless sensitive data is allowed in DevTools' settings.

Can I replay a request from the HAR?

Copy it as a curl command from the request's details and run it in a terminal; the command carries the method, URL, headers and body exactly as the browser sent them, minus the HTTP/2 pseudo-headers. To edit and send it from the browser instead, paste that curl command into the Online API Client's import.