Skip to content
JustDevTools
  • JSON formatter and validator
    Format, minify and validate JSON, with the exact line and column of any syntax error.
  • JWT decoder
    Read a JWT's header and payload, with issued-at and expiry times shown as real dates.
  • Base64 encoder and decoder
    Encode and decode Base64 and Base64URL, with full Unicode support.
  • JSON to TypeScript, Zod and Java
    Paste a JSON response and get TypeScript interfaces, a Zod schema or Java classes with Jackson annotations.
  • YAML to JSON converter
    Convert YAML to JSON and JSON to YAML, with the exact line of any syntax error. Handles multi-document files.
  • Regex tester
    Test JavaScript regular expressions with live match highlighting, capture groups and replace preview.
  • URL encoder and decoder
    Percent-encode and decode URLs and query values, and break a URL into its parts and parameters.
  • Unix timestamp converter
    Convert Unix timestamps in seconds or milliseconds to dates, and dates back to timestamps.
  • Cron expression explainer
    See what a cron expression means in plain English, what each field does and the next times it will run.
  • JSON to CSV converter
    Turn a JSON array into CSV for Excel or Google Sheets, or a CSV file into JSON. Nested objects become columns.
  • UUID generator and inspector
    Generate UUID v4 and time-ordered v7 in bulk, or paste a UUID to see its version and timestamp.
  • Text diff checker
    Compare two texts line by line and see exactly what was added, removed or changed.
  • Hash and HMAC generator
    SHA-256, SHA-1, SHA-384 and SHA-512 hashes and HMAC signatures of text, in hex or Base64.
  • Markdown previewer
    Write Markdown on the left and see it rendered live on the right, with GitHub-style tables and task lists.

Unix timestamp converter

Convert Unix timestamps in seconds or milliseconds to dates, and dates back to timestamps.

Runs locally. Nothing you paste leaves this tab.

Current Unix time …

Numbers are in

Read as seconds, based on the number of digits.

Converted

Unix seconds
1717171717
Unix milliseconds
1717171717000
ISO 8601 (UTC)
2024-05-31T16:08:37.000Z
ISO 8601 (your time zone)
2024-05-31T21:38:37+05:30
Readable (your time zone)
Friday, May 31, 2024 at 9:38:37 PM GMT+5:30
HTTP / RFC 7231
Fri, 31 May 2024 16:08:37 GMT

What a Unix timestamp is

A Unix timestamp counts the time since 1 January 1970 00:00:00 UTC, called the Unix epoch. It has no time zone: the same moment has the same timestamp everywhere. That makes it a good way to store and compare times, and it’s why APIs, databases and JWTs use it.

Seconds or milliseconds?

Most backends and JWT claims use seconds (10 digits today, like 1717171717). JavaScript’s Date.now() and Java’s System.currentTimeMillis() use milliseconds (13 digits). Some systems go further: Go and many logging tools use nanoseconds (19 digits). This tool picks the unit from the number of digits. Override it if your value is from an unusual date range.

A date in January 1970 almost always means milliseconds were read as seconds. A date tens of thousands of years from now means the reverse.

Dates without a time zone

2024-05-31T16:08:37Z and 2024-05-31T21:38:37+05:30 are exact moments. A date written without Z or an offset, like 2024-05-31 16:08, is read in your browser’s time zone, so it gives a different timestamp for someone in another country. When you send times between systems, always include the offset or use UTC.

In code

// JavaScript
Math.floor(Date.now() / 1000);              // now, in seconds
new Date(1717171717 * 1000).toISOString();  // "2024-05-31T16:08:37.000Z"

// Java
Instant.now().getEpochSecond();
Instant.ofEpochSecond(1717171717);          // 2024-05-31T16:08:37Z

// Python
import time, datetime
int(time.time())
datetime.datetime.fromtimestamp(1717171717, datetime.UTC)

// SQL (PostgreSQL)
SELECT to_timestamp(1717171717);
SELECT extract(epoch FROM now())::bigint;

The year 2038 problem

Systems that store seconds in a signed 32-bit integer overflow at 2147483647, which is 19 January 2038 03:14:07 UTC. Use 64-bit integers for timestamps in new schemas and APIs.