Zero Snippet

Unix timestamp converter — epoch seconds, milliseconds, UTC, and local time

Use this free Unix timestamp converter online to translate POSIX / Unix epoch values into human-readable dates, compare UTC ISO 8601 with your local time zone, and go the other way—from a calendar pick or pasted ISO string back to Unix seconds and milliseconds. Everything runs in your browser, which suits log triage, API payloads, and database columns without uploading sensitive data. For token timelines, continue with the JWT decoder; for recurring jobs, pair this page with the cron expression generator and cron explainer.

Unix epoch → human-readable time

Paste seconds, milliseconds, or use Auto (≤10 digit magnitude as seconds, longer as milliseconds).

Unit
Local
Monday, January 1, 2024 at 12:00:00 AM UTC
UTC (ISO 8601)
2024-01-01T00:00:00.000Z
Unix seconds
1704067200
Unix milliseconds
1704067200000

Date & time → Unix epoch

Pick a local date/time, or paste ISO 8601 (UTC with Z or an offset)—ISO overrides the picker when non-empty.

Choose a local date/time or paste an ISO 8601 string.

Why developers still live in Unix time

The Unix epoch is the instant 1970-01-01T00:00:00Z. Storing instants as integers avoids ambiguous string formats, sorts naturally, and matches what you see in Linux logs, many SQL databases, and most JSON APIs. The recurring confusion is whether a field counts seconds or milliseconds—off by three orders of magnitude, dates look centuries wrong. This tool makes the unit explicit and shows both representations so you can paste once and verify against Grafana, CloudWatch, or Splunk without mental arithmetic.

When you work across regions, keep UTC as the contract in storage and transport, then render local time only in UIs. If you need to sanity-check headers or caching, our HTTP header checker and redirect chain checker complement timestamp review for deployments and CDN debugging.

How to use this Unix timestamp converter (step by step)

  1. Epoch → readable: Paste a numeric value from logs or JSON. Choose Auto if you are unsure: values with up to ten digits in the magnitude are treated as seconds; longer digit runs default to milliseconds. Override with explicit Seconds or Milliseconds when the API contract is known.
  2. Read the local line for how the instant appears on your machine, and the UTC ISO 8601 string for canonical comparisons. Copy either form for tickets or documentation.
  3. Click Use current time to drop in the present instant as Unix seconds—handy when you draft exp examples or reproduce bug reports.
  4. Readable → epoch: Use the datetime-local control for wall-clock times in your zone, or paste an absolute ISO 8601 value (including Z or offsets). When the ISO field is non-empty, it takes precedence over the picker.
  5. Copy Unix seconds for languages and claims that expect ten-digit fields, or Unix milliseconds for JavaScript Date.now() style APIs.

Seconds vs milliseconds: quick reference

Unix seconds appear in OpenID Connect metadata, many OAuth2 JWT claims, C time_t conventions, and PostgreSQL EXTRACT(EPOCH ...) results (often double, but conceptually seconds). Milliseconds dominate browser JavaScript, some mobile SDKs, and streams where sub-second ordering matters. If you divide milliseconds by one thousand you should recover the second count—when you cannot, suspect nanoseconds (rare in JSON) or a stringly-typed bug.

ISO 8601, time zones, and daylight saving

Strings such as 2026-04-04T14:30:00Z pin an unambiguous instant. Without a zone suffix, browsers interpret datetime strings in a history-sensitive way; the picker path on this page is meant for local intent. For production systems, prefer storing UTC plus a known offset or using a library like Temporal once widely adopted. When you serialize configuration, our JSON formatter and YAML to JSON tools help validate the surrounding document while you adjust timestamps.

SEO, analytics, and event pipelines

Marketing engineers comparing Google Analytics, Snowplow, or warehouse export timestamps can normalize on this page before joining to CRM data. If you are validating sitemap or indexing timing, the XML sitemap generator and robots.txt generator live alongside developer utilities in this project so you can move between technical SEO artifacts and low-level time debugging without leaving the same toolkit.

Related developer tools

Browse the full code and developer tools catalog. Highlights:

  • JSON Formatter & Validator — Format, validate, minify, and explore JSON in a collapsible tree—fix payloads before they hit production.
  • JSON to CSV Converter — Turn JSON arrays into downloadable CSV with automatic column detection for spreadsheets and BI tools.
  • JSON to YAML Converter — Convert JSON to readable YAML for configs and Kubernetes—copy or download the result.
  • CSV to JSON Converter — Paste or upload CSV and get structured JSON with header-aware typing for APIs and apps.
  • YAML to JSON Converter — Parse YAML to valid JSON with clear errors—ideal for CI configs and cloud templates.
  • XML Formatter & Validator — Beautify and validate XML with structure insight and actionable parse errors.
  • Regex Tester & Debugger — Test patterns live with highlights, capture groups, and flags—debug regex without leaving the browser.
  • SQL Formatter — Pretty-print SQL with indentation and keyword casing for readable queries and code review.
  • HTML Formatter & Minifier — Beautify or minify HTML and compare raw markup with a quick rendered preview.
  • CSS Formatter & Minifier — Format messy stylesheets or minify CSS for faster loads—keep design tokens consistent.
  • JavaScript Formatter & Minifier — Pretty-print or minify JavaScript for debugging locally and shipping smaller bundles.
  • HTML to Markdown Converter — Convert HTML snippets to Markdown for docs, CMS migrations, and README cleanup.
  • Markdown to HTML Converter — Turn Markdown into HTML with a live preview—handy for emails, blogs, and static pages.
  • Code Diff Checker — Compare two code blocks side by side with clear add/remove highlighting for reviews.

Frequently asked questions

What is a Unix timestamp?
A Unix timestamp counts time from the Unix epoch: midnight UTC on 1 January 1970. It is usually stored as whole seconds (ten digits through the year 2286) or as milliseconds since the same instant (thirteen digits). APIs, databases, and log lines often emit one of these forms.
How do I know if my value is in seconds or milliseconds?
Seconds are typically ten digits (or fewer for dates before 2001). Millisecond values are usually thirteen digits. If you are unsure, use the Auto mode on this page, or compare against a known date: milliseconds are one thousand times larger than seconds for the same instant.
Does this tool send my timestamps to a server?
No. Parsing and formatting run entirely in your browser with JavaScript’s Date APIs. Nothing you type is uploaded unless you copy it elsewhere yourself.
Why does my local time differ from UTC?
UTC is a fixed reference; your local clock follows your operating system time zone and daylight saving rules. This converter shows both so you can line up log entries (often UTC) with what you see on your machine.
Can I convert human-readable dates back to Unix time?
Yes. Use the date and time picker for your local zone, or paste an ISO 8601 string (for example with a Z suffix for UTC). The tool outputs both seconds and milliseconds since the epoch.
What about timestamps before 1970 or very large values?
JavaScript Date supports negative values for instants before 1970-01-01 UTC and large positive values within its internal range. If a number is out of range, the tool will show an error instead of a misleading date.
How is this related to JWT or API debugging?
JSON Web Tokens and many OAuth responses carry numeric exp, iat, or nbf claims as Unix seconds. After converting here, you can paste tokens into the site’s JWT decoder or compare with cron schedules from the cron tools in the developer catalog.