ToolGuest
Convert Unix epoch seconds or milliseconds into readable dates — and human dates back into timestamps — in under 50 milliseconds, entirely inside your browser. Every conversion runs through native client-side Web APIs, so there is no upload, no signup and no ad stack: zero data tracking, zero retention, zero ads.
10 digits = seconds · 13 digits = milliseconds. Auto-detect reads both.
Type a date or pick one above — the epoch appears the moment the value is valid.
| Input | Detected | UTC | ISO 8601 | Epoch (s) |
|---|---|---|---|---|
| Paste a list above, then hit Convert all. | ||||
Everything runs in your browser via the native Date and Intl.DateTimeFormat APIs. Zero network requests.
No banners, no cookie wall, no sign-up. Open the page, paste the value, read the answer.
Conversion happens in your tab. Log lines, session IDs and customer timestamps never touch a server.
The current epoch in seconds and milliseconds, updating every frame, so you never leave the page to check "now".
Read one instant in San Francisco, New York, London, Berlin and Sydney simultaneously — no mental arithmetic.
Paste a whole column from a log or CSV export and convert every row at once, then copy the table straight out.
Choose Epoch → Date to decode a number, or Date → Epoch to encode a calendar date.
Drop in the timestamp or pick a date. Auto-detect reads 10-digit seconds and 13-digit milliseconds without asking.
UTC, ISO 8601, local time, GMT, relative time and the weekday appear together, plus the same instant in five tech hubs.
Each row has its own copy button that flashes ✓ Copied. For long lists, use the Batch tab and copy the table as TSV.
The same 10-digit number means four different things depending on where your cluster, your CI runner and your customer happen to be.
A Pacific-time engineer triaging a Stripe or Cloudflare webhook sees created: 1767225600 and needs it in a human date before the incident call starts. Paste it once and the tool prints the ISO 8601 string for the ticket, the local Pacific time for the stand-up and the UTC value that the API actually recorded — all three side by side, so nobody argues about the offset on the bridge.
UK teams live half the year in GMT and half in BST, which is exactly why settlement records are stored as epoch. When a trade timestamp must be reconciled against a ledger, the GMT row here gives you the unambiguous value, while the Europe/London row shows what the trader saw on their screen. Reading both prevents the classic one-hour-off bug that only appears in summer.
German engineering teams often store event times in UTC but must present audit logs in CET. The Berlin row converts without a round trip to any third-party service, so timestamped GDPR access records stay entirely on the machine that is doing the audit. That matters when the log lines you are inspecting contain identifiers you are not allowed to paste into someone else's server.
A Toronto backend team serving US customers routinely fields support tickets that quote a millisecond value from a browser console. Drop the 13-digit number into the converter and the milliseconds are detected automatically, so the engineer gets the ISO string and the relative "3 hours ago" phrasing they can paste straight back to the customer without doing arithmetic in their head.
A Manhattan platform team chasing a settlement discrepancy reads a millisecond value straight out of a
Postgres bigint column.
Pasting the 13-digit number returns the ISO 8601 string for the audit trail, the Eastern time the operator
actually saw on the dashboard, and the UTC value the exchange recorded — three answers that normally require
three separate systems. Keeping all three on one screen is what closes a reconciliation call in minutes
instead of hours.
Madrid runs on CET, but the SaaS products a Spanish team integrates with are usually timestamped in UTC and their support teams sit in US timezones. Converting a single incident timestamp into UTC, CET and Pacific at once removes the two-step translation that turns a fifteen-minute triage into an afternoon of Slack messages. Because nothing is uploaded, a Spanish team can also paste customer-identifying log lines without triggering a cross-border data transfer question.
An Australian SRE team is routinely the first to see alerts from infrastructure that logs in UTC, while the business day in London has not started and the US West Coast is still asleep. Reading the same epoch value in Sydney, UTC and London at once is how an on-call engineer decides whether to wake anyone — and the relative time row makes it obvious whether an alert fired four minutes or four hours ago.
No conversion endpoint. No query log. The date math runs on the same CPU that renders this page.
A Unix timestamp is a count of seconds from the epoch. Converting it is one multiplication, because
JavaScript’s Date
constructor takes milliseconds. The whole decode is a single expression:
new Date(1767225600 * 1000).toISOString();
// "2026-01-01T00:00:00.000Z"The reverse direction parses an ISO 8601 string to an absolute instant and floors it back to whole seconds, which is exactly what a database column expects:
Math.floor(Date.parse("2026-01-01T00:00:00Z") / 1000);
// 1767225600Every zone in the grid is rendered by the platform’s own internationalization API, so daylight-saving rules come from the browser’s tzdata rather than a bundled database that goes stale. Passing an IANA identifier is all it takes:
new Intl.DateTimeFormat("en-GB", {
timeZone: "Europe/Berlin",
dateStyle: "medium", timeStyle: "long"
}).format(1767225600 * 1000);
// "1 Jan 2026, 01:00:00 CET"
That is why the same instant can legitimately be Tuesday in San Francisco and Wednesday in Berlin, and why
the grid is more useful than a single “converted” value. Relative wording such as
“3 hours ago” is produced the same way, through
Intl.RelativeTimeFormat.
The page contains no fetch,
no XMLHttpRequest and no
sendBeacon call anywhere in
its conversion logic. Whatever you paste is read into a JavaScript variable, converted, and rendered back into the
DOM — it is never serialized into a request body, never appended to a URL and never written to a cookie.
You can verify the claim yourself in DevTools: open the Network panel, convert a value, and watch no request fire.
Or simply disconnect from the internet — the tool keeps working, because there was never a server involved.
For teams under GDPR or CCPA, that changes the compliance question. Because no timestamp you paste is transmitted to ToolGuest, there is no processor acting on your data for the conversion itself, so no data processing agreement is required to use the tool on production log lines. The only state the page persists is your light-or-dark theme preference, kept in your own browser’s local storage. The only outbound request the page can make is an anonymous star rating, and only if you deliberately click one.
A Unix epoch timestamp converter is a client-side browser utility that translates the integer count of seconds elapsed since 1 January 1970 UTC into a human-readable calendar date and time, and converts human dates back into epoch values, resolving seconds versus milliseconds entirely in the browser.
ToolGuest's converter runs entirely in your browser, so no timestamp or log line ever leaves your device.
The same conversion, without the ad stack, the heavy tracking scripts or the round trip to a server.
| Capability | Legacy converters | ToolGuest NEW |
|---|---|---|
| Adverts, pop-ups & interstitials | ⚠️ Multiple banner units | ✅ Zero, ever |
| Where the conversion runs | ⚠️ Server round trip | ✅ 100% in-browser |
| Data logging | ⚠️ Requests logged server-side | ✅ Zero logging |
| Live ticking epoch clock | ❌ Static value only | ✅ Seconds + milliseconds |
| Multi-timezone view | ❌ One zone, or none | ✅ Five hubs + custom |
| Batch conversion | ❌ One value at a time | ✅ Whole column, TSV out |
| Seconds vs milliseconds detection | ⚠️ Manual toggle only | ✅ Automatic + override |
| Typical page weight | ⚠️ Often 1 MB or more | ✅ 191 KB measured |
| Signup, cookies or tracking | ⚠️ Third-party trackers | ✅ None |
| Dark mode | ❌ Light only | ✅ Full theme |
| Where the value you paste goes | ⚠️ Sent to a conversion endpoint | ✅ Never leaves the tab |
| Usage limits | ⚠️ Quota, or a paid tier for batch | ✅ Unlimited, no account |
| Compliance burden | ⚠️ DPA needed to paste log data | ✅ No data transfer, no DPA |
Our figures are measured in Chrome DevTools against this live page in November 2026: 15 requests and 190.9 KB over the wire, of which 25.2 KB is the HTML document and 121.2 KB is the Tailwind runtime. The page’s own conversion logic is under 20 KB. Competitor figures are indicative, and competitor behaviour may change over time.
A Unix epoch timestamp is the number of seconds elapsed since 00:00:00 UTC on 1 January 1970, ignoring leap seconds. Because it carries no timezone, it is the lowest common denominator every database, API and log format can agree on.
Count the digits. Ten digits (1767225600) is seconds and lands in a sensible year; thirteen digits (1767225600000) is milliseconds. JavaScript's Date.now() returns milliseconds, while most Unix tools and database columns store seconds — which is where the “year 55000” bug comes from.
Every conversion renders in UTC, ISO 8601 and your browser's local zone at once, alongside a fixed grid for San Francisco, New York, London, Berlin and Sydney. The timezone selector adds 25 more curated zones — Madrid, Paris, Toronto, Tokyo, Singapore, São Paulo, Auckland and others — each resolved through the browser's own Intl.DateTimeFormat, so daylight-saving transitions are handled correctly.
Yes. There is no server-side processing, so no personal data is transferred to ToolGuest and no data processing agreement is needed for the conversion itself. No advertising or fingerprinting scripts load; the only measurement is cookieless, anonymous analytics. The only stored value is your theme preference, held in your own browser's local storage and never transmitted. The only outbound request is an anonymous star rating, and only if you click one.
No. There is no signup, no email gate, no API key and no usage quota. Open the page and convert. Because every calculation runs in your browser, there is nothing to authenticate against and no session to expire.
Yes. Every output row has its own copy button that flashes a confirmation on click, so you can lift the ISO 8601 string, the UTC value or the epoch number into a ticket, a spreadsheet or a shell command without selecting text by hand. The Batch tab adds Copy as TSV for whole columns.
Instant. Each conversion is a single arithmetic operation on a native JavaScript Date object that completes in well under 50 milliseconds — typically under 5 milliseconds — with no network round trip, so results update as you type rather than after a request returns.
Yes. Every feature — live clock, bi-directional conversion, the multi-timezone grid and batch mode — is free with no daily cap, no paywall and no trial. There are no ads, no sponsored placements and no upsell, so nothing is withheld behind a plan.
ISO 8601 writes dates as YYYY-MM-DDTHH:MM:SSZ. It sorts lexicographically, always states its offset and never depends on locale, so it is the default in JSON payloads, OpenAPI schemas, Kubernetes manifests and CI logs. This tool emits the canonical UTC form with a trailing Z.
Yes. JavaScript dates are 64-bit floating point, so they are unaffected by the 32-bit signed overflow that breaks naive C and PHP systems on 19 January 2038. Negative timestamps are read as dates before the epoch, and very large values convert correctly up to the limits of IEEE-754.
Yes. Open the Batch tab, paste one value per line — epochs, ISO strings or plain dates, mixed freely — and press Convert all. Each row reports the detected unit and the converted UTC and ISO values, and Copy as TSV puts the whole table on your clipboard ready for a spreadsheet or a ticket.