Rust Unix Timestamp Converter

Unix timestamps in Rust

Rust gives you two good options for epoch time. The standard library’s std::time::SystemTime reads the clock and measures durations since UNIX_EPOCH, with no dependencies. The chrono crate adds calendar dates, formatting, parsing, and time zones. The live parser above checks any value you paste, and the snippet panel generates Rust code for both approaches. Everything runs in your browser, so no timestamp leaves the tab.

Standard library: SystemTime and UNIX_EPOCH

SystemTime::now().duration_since(UNIX_EPOCH) returns a Result<Duration, SystemTimeError>. It is an error only if the system clock is set before 1970, so handle it with expect and a clear message rather than a bare unwrap.

use std::time::{Duration, SystemTime, UNIX_EPOCH};

let since = SystemTime::now()
    .duration_since(UNIX_EPOCH)
    .expect("system clock is before 1970");
let secs: u64 = since.as_secs();     // e.g. 1715429912
let millis: u128 = since.as_millis();

// Unix seconds -> SystemTime
let t = UNIX_EPOCH + Duration::from_secs(1_715_429_912);

The standard library has no calendar formatting: it cannot print “2024-05-11” by itself. That is where chrono comes in.

chrono: DateTime::from_timestamp and Utc

With chrono = "0.4" in Cargo.toml, the current constructor is DateTime::from_timestamp(secs, nanos). It returns Option<DateTime<Utc>>, with None for out-of-range values:

use chrono::{DateTime, Utc};

let dt: DateTime<Utc> = DateTime::from_timestamp(1_715_429_912, 0).expect("in range");
println!("{}", dt.to_rfc3339());                // 2024-05-11T12:18:32+00:00
println!("{}", dt.format("%Y-%m-%d %H:%M:%S")); // 2024-05-11 12:18:32

let now: i64 = Utc::now().timestamp();           // current Unix seconds
let from_ms = DateTime::from_timestamp_millis(1_715_429_912_000).unwrap();
let parsed = DateTime::parse_from_rfc3339("2024-05-11T12:18:32Z").unwrap();
assert_eq!(parsed.timestamp(), 1_715_429_912);

The output confirms 1715429912 is Saturday, May 11, 2024 at 12:18:32 UTC. Note that DateTime::from_timestamp takes an i64, so negative values (dates before 1970) work: from_timestamp(-86_400, 0) is 1969-12-31 00:00:00 UTC.

Deprecated chrono APIs to migrate away from

Recent chrono 0.4 releases deprecated several older constructors. If you see warnings, migrate them:

• NaiveDateTime::from_timestamp_opt(s, 0) → DateTime::from_timestamp(s, 0), then .naive_utc() if you really need a naive value.
• Utc.timestamp(s, 0) → DateTime::from_timestamp(s, 0), or Utc.timestamp_opt(s, 0).unwrap().
• dt.timestamp_millis() remains available for getting milliseconds back out.

For named IANA zones such as Europe/Paris, add the chrono-tz crate and call dt.with_timezone(&chrono_tz::Europe::Paris). chrono by itself only knows Utc, Local, and fixed offsets.

std, chrono, or the time crate?

Use the standard library alone when you only need the current epoch value, for example to stamp a log line, set a cache expiry, or build a JWT exp claim. It adds no dependencies and compiles everywhere. Reach for chrono when you need to format dates for people, parse RFC 3339 or custom strings, or do calendar arithmetic. The time crate (0.3) is a popular alternative with a similar role: OffsetDateTime::from_unix_timestamp(1_715_429_912) returns a Result and formats with its own description syntax. Pick one of the two date crates per project and convert at the boundaries. Mixing them in one module makes timestamps harder to follow in code review.

Common Rust timestamp pitfalls

• Unsigned vs signed. Duration::as_secs() is u64, but chrono timestamps are i64. Convert explicitly with i64::try_from instead of casting with as.
• Milliseconds from JSON. A 13-digit value passed to from_timestamp lands tens of thousands of years in the future or returns None. Use from_timestamp_millis. Details: seconds vs milliseconds.
• SystemTime is not monotonic. For measuring elapsed time inside a process, use std::time::Instant. Use SystemTime for wall-clock timestamps.
• Formatting with Local in servers. Output then depends on the host’s timezone. Log and store in Utc.

Coming from Go? The Go timestamp page shows the same conversions with time.Unix. For the history of the epoch itself, see epoch time explained.

Frequently asked questions

Related tools