Introduction

In Swift, the standard way to get Unix epoch time is through Date and its timeIntervalSince1970 property. That value represents the number of seconds since 1970-01-01 00:00:00 UTC. The main follow-up decision is whether you want fractional seconds as a Double, whole seconds as an integer, or milliseconds for APIs that use a larger unit.

The Basic Swift API

The direct solution is short:

1import Foundation
2
3let seconds = Date().timeIntervalSince1970
4print(seconds)

timeIntervalSince1970 returns a TimeInterval, which is just a typealias for Double. That means you get sub-second precision.

Example output might look like:

1772904000.123456

This is usually what you want when precision matters.

Whole Seconds As An Integer

If you need a Unix timestamp as a whole number, convert it explicitly.

1import Foundation
2
3let epochSeconds = Int(Date().timeIntervalSince1970)
4print(epochSeconds)

This truncates the fractional part. That is a common requirement for:

• REST APIs expecting integer timestamps
• database fields stored as seconds
• log formats using integer Unix time

Be aware that this is truncation, not rounding.

Milliseconds Since Epoch

Some APIs expect milliseconds instead of seconds. Multiply before converting.

1import Foundation
2
3let epochMilliseconds = Int(Date().timeIntervalSince1970 * 1000)
4print(epochMilliseconds)

That pattern is common when interacting with JavaScript systems, analytics pipelines, or storage layers that use millisecond timestamps.

Convert A Specific Date To Unix Time

You are not limited to the current time. Any Date can be converted to epoch seconds.

1import Foundation
2
3let formatter = ISO8601DateFormatter()
4let date = formatter.date(from: "2026-03-07T12:00:00Z")!
5
6print(date.timeIntervalSince1970)

This is useful when parsing external timestamps and then normalizing them into Unix time for comparison or storage.

Convert Unix Time Back To Date

The inverse operation is just as important.

1import Foundation
2
3let timestamp: TimeInterval = 1772904000
4let date = Date(timeIntervalSince1970: timestamp)
5
6print(date)

For milliseconds, divide by 1000 first:

let milliseconds: TimeInterval = 1772904000123
let date = Date(timeIntervalSince1970: milliseconds / 1000)

Keeping the unit straight is the critical part.

Time Zones Do Not Change The Timestamp

Unix epoch time is based on UTC. The numeric timestamp represents an absolute moment in time, not a local clock display. Local time zones only affect how you format or display the Date later.

1import Foundation
2
3let now = Date()
4print(now.timeIntervalSince1970)

That value is the same absolute instant regardless of whether the phone is in Toronto, London, or Tokyo. If the displayed date string changes, that is a formatting concern, not a timestamp concern.

Choosing The Right Numeric Type

For current timestamps, Int is usually fine on modern Apple platforms. But if you care about precision or cross-platform serialization, keep a few rules in mind:

• use Double when fractional seconds matter
• use Int when an API expects whole seconds or milliseconds
• document the unit clearly so seconds are not mistaken for milliseconds later

A lot of timestamp bugs are really unit bugs.

Common Pitfalls

• Forgetting that timeIntervalSince1970 returns seconds, not milliseconds.
• Converting to Int too early and unintentionally losing fractional precision.
• Mixing up milliseconds and seconds when sending data to external APIs.
• Assuming local time zone changes the epoch number itself.
• Parsing or formatting a Date incorrectly and blaming the Unix timestamp logic.

Summary

• In Swift, get Unix epoch time with Date().timeIntervalSince1970.
• The result is a Double in seconds since the Unix epoch.
• Convert to Int if you need whole seconds.
• Multiply by 1000 if an API expects milliseconds.
• Time zones affect display formatting, not the epoch timestamp value itself.