Skip to content
FormatKit

Free online timestamp format converter

Timestamp converter that names the format first

Paste anything that might be a timestamp and this converter works out what it is before it converts it — an eighteen-digit Windows number, a MongoDB ObjectId, a spreadsheet serial or a dated string all identify themselves here, with the reasoning shown rather than assumed. It is free and needs no account, and the same instant is then rewritten in ten formats at once: Unix time, ISO 8601, RFC 3339, RFC 2822, SQL DATETIME, Excel serial, .NET ticks, Windows FILETIME, ObjectId and Apple absolute time. Any IANA time zone can be applied to the forms that carry none of their own, with the offset taken from the date being converted rather than from today.

  • 100% free
  • No signup
  • 10 formats
  • Format auto-detection
  • Daylight saving resolved
Try one:

Read as MongoDB ObjectId

2024-03-15T03:46:42Z

Friday, 15 March 2024 at 04:46:42 in Europe/Berlin, UTC+01:00

24 hexadecimal characters, and the leading four bytes of an ObjectId are a Unix second count.

The same instant in every format on this page
Unix seconds1710474402
Unix milliseconds1710474402000
ISO 8601, UTC2024-03-15T03:46:42Z
ISO 8601 basic20240315T034642ZThe separator-free profile, which RFC 3339 does not allow and which S3 keys and log file names use anyway.
RFC 3339 (Europe/Berlin)2024-03-15T04:46:42+01:00RFC 3339 insists on an offset, so this form says the same thing as the UTC row without moving the wall clock.
RFC 2822 (Europe/Berlin)Fri, 15 Mar 2024 04:46:42 +0100
SQL DATETIME (Europe/Berlin)2024-03-15 04:46:42MySQL DATETIME and SQL Server datetime2 both store this and forget the offset; TIMESTAMP WITH TIME ZONE does not.
Excel serial (Europe/Berlin)45366.199097222A cell holds no time zone, so this is the wall clock in the zone above written as a fraction of a day.
.NET ticks638460712020000000
Windows FILETIME133549480020000000
MongoDB ObjectId65f3c4a20000000000000000Only the first four bytes carry time; the sixteen zeros stand in for the random and counter bytes, which hold none.
Apple absolute time732167202Negative until 2001, because CFAbsoluteTime counts from the start of that year rather than from 1970.

Field guide: eleven shapes, one instant

Every row below is 15 March 2024 at 03:46:42 UTC, written the way a different system insists on writing it. Read down the epoch column to see why the numbers differ so wildly: they are counting the same moment from six different starting points, in units ranging from a day to a hundred nanoseconds.

FormatCounts fromThat instantWhere you meet it
Unix seconds1970-01-011710474402POSIX APIs, JWT claims, almost every REST field named at, on or _ts
Unix milliseconds1970-01-011710474402000JavaScript, the JVM, Kafka offsets and anything that passed through a browser
ISO 8601 / RFC 3339no epoch2024-03-15T03:46:42ZJSON payloads, structured logs, OpenAPI date-time fields
RFC 2822no epochFri, 15 Mar 2024 03:46:42 +0000Email Date: headers, RSS feeds, HTTP dates in their close cousin RFC 1123
SQL DATETIMEno epoch2024-03-15 03:46:42MySQL DATETIME, SQL Server datetime2, Postgres timestamp without time zone
Excel serial1899-12-3045366.157430556Spreadsheet cells, CSV exports that lost their formatting
.NET ticks0001-01-01638460712020000000DateTime.Ticks, Azure table keys, anything serialised out of C#
Windows FILETIME1601-01-01133549480020000000Win32 APIs, NTFS metadata, Active Directory lastLogonTimestamp
MongoDB ObjectId1970-01-0165f3c4a2e1b9d3f4a8c7d6e5The _id of any document Mongo generated for you
Apple absolute time2001-01-01732167202plist files, Core Data, Safari and Messages databases
HFS+ / classic Mac1904-01-013793319202Files copied off an HFS+ volume, older QuickTime containers

How to convert between timestamp formats

Paste the unknown value, confirm what it is, and copy the shape the next system needs.

  1. Give it the value you cannot place

    Drop the string into the field. A keyboard paste that lands nowhere in particular is caught too, and the first line of the clipboard is what gets used. Numbers, hexadecimal ObjectIds, dated strings with or without an offset and spreadsheet serials are all accepted; if you have nothing to hand, the six example buttons load one of each shape.

  2. Read what it decided, and disagree if you want

    The panel names the format and gives the reason in one line — the digit count, the epoch that made the number land in a plausible decade, the four leading bytes of an ObjectId. Where more than one reading survives, and ten digits are both Unix seconds and a believable Apple absolute time, the alternatives are listed underneath with the date each one produces so you can switch with a click.

  3. Take the format the other system wants

    The table underneath rewrites that single instant in every format on the page, each with its own copy button and a note on what the receiving system will do with it. Change the zone selector to move the readings that carry no zone of their own — SQL DATETIME, the Excel serial and the RFC forms — and the offset in the header updates to whatever was in force on that date rather than today.

Technical specifications

Formats identifiedUnix seconds, milliseconds, microseconds and nanoseconds, ISO 8601, RFC 3339, RFC 2822, SQL DATETIME, Excel serial, .NET ticks, Windows FILETIME, MongoDB ObjectId, Apple absolute time and HFS+ 1904 time
Epochs applied1970-01-01 for Unix and ObjectId, 1601-01-01 for FILETIME, 0001-01-01 for .NET, 2001-01-01 for Apple, 1904-01-01 for HFS+, 1899-12-30 for Excel
Detection ruleEvery reading is computed and then filtered: outside 1900-2200 it is dropped, inside 1995-2045 it is offered first
Precision keptNine fractional digits from an ISO string, 100 ns for ticks and FILETIME, one whole second for ObjectId and Apple values
Zone handlingThe full IANA identifier list through Intl.DateTimeFormat, with the offset taken at the converted instant rather than today — a March 2024 date in Berlin resolves to UTC+01:00
Ambiguity reportedRepeated and skipped local hours are named, and every surviving reading of the same characters stays listed with the date it produces
Input ceiling200 characters, one value at a time; a multi-line paste keeps the first line
Processing locationEntirely in this browser tab, with nothing uploaded and nothing stored

Frequently asked questions

I have an 18-digit number. What format is it?

Almost certainly Windows FILETIME or .NET ticks, and the leading digits separate them: FILETIME values for dates in this decade start with 13, while .NET ticks start with 63. Both count 100-nanosecond intervals, but from different origins — 1 January 1601 for FILETIME and 1 January 0001 for .NET — so the same date produces numbers roughly five times apart. An 18-digit value that is neither is probably nanoseconds since 1970, which for a current date starts with 17.

What is the difference between ISO 8601 and RFC 3339?

RFC 3339 is a strict subset of ISO 8601 with the optional parts removed. ISO 8601 allows week dates like 2024-W11-5, ordinal dates, the separator-free basic form 20240315T034642Z, a comma as the decimal marker and a local time with no offset at all; RFC 3339 demands a full calendar date, a T or a space, and an offset that is either Z or ±HH:MM. In practice that means every RFC 3339 timestamp is valid ISO 8601 and plenty of ISO 8601 is not valid RFC 3339, which is exactly the gap a parser falls into when an API sends a week date.

Can I get the creation date out of a MongoDB ObjectId?

Yes — the first four bytes of the twelve are a big-endian Unix second count, so the leading eight hex characters convert straight to a date. 65f3c4a2 is 1710474402, which is 15 March 2024 at 03:46:42 UTC. The remaining eight bytes are a random per-process value and a counter and carry no time at all, which is why the ObjectId row in the table above pads them with zeros. Resolution stops at one second, so two documents written in the same second cannot be ordered by their timestamps alone.

Why is my Excel date a day out?

Because Excel believes 1900 was a leap year. Lotus 1-2-3 shipped that bug in 1983, Excel copied it deliberately so that spreadsheets would interoperate, and serial 60 is therefore 29 February 1900 — a day that never existed. Every serial from 1 to 59 is consequently one greater than the true day count and nothing before 1 March 1900 converts cleanly, which is why the table above refuses to print a serial for those dates rather than printing a wrong one. Apple made things worse for a while by shipping a 1904 date system in Mac Excel, so a workbook moved between platforms could shift by 1,462 days.

My SQL DATETIME has no time zone. Which one does this page use?

The one in the selector, and that choice changes the answer. A MySQL DATETIME or a SQL Server datetime2 stores a wall-clock reading with no offset attached, so the string 2024-03-15 03:46:42 is not a moment until somebody names a zone — read in Berlin it is an hour earlier in absolute terms than read in London. The converter shows both the zone reading and the UTC reading as separate candidates for that reason, and if the value falls in an hour that a daylight-saving change repeated, it says which of the two passes it took.

What is Apple absolute time, and why does it come out negative?

Apple absolute time counts from 1 January 2001, the epoch Cocoa picked for CFAbsoluteTime and NSDate, so any date before that year comes out below zero. You meet it in plist files, Core Data stores, Safari history databases and iOS backups, usually as a float with a fractional part. Its cousin still turns up too: HFS+ and the classic Mac OS counted seconds from 1904, which is why a file copied off an old Mac volume can carry a timestamp about 2.08 billion higher than the Unix value for the same moment.

How does the page decide which format a number is?

It tries every reading and keeps the ones that land on a believable date. The same digits are interpreted as Unix seconds, milliseconds, microseconds and nanoseconds, as FILETIME, as .NET ticks, as an Excel serial and against the 2001 and 1904 Apple epochs; anything falling outside 1900 to 2200 is discarded outright, and anything between 1995 and 2045 is promoted to a first answer. That is why a value can be reported with confidence with no metadata at all — the wrong epoch usually throws a date into the seventeenth century, which is a strong enough signal on its own.

About timestamp formats

Every platform that ever needed to record a moment picked its own zero and its own unit, and none of them agreed. Unix chose seconds from 1970, Windows chose hundred-nanosecond intervals from 1601 because that year begins a 400-year Gregorian cycle, .NET went back to the year 1, Cocoa started at 2001, GPS started in 1980 and refuses leap seconds outright, and Excel counts days from the end of 1899 with a fictional extra day baked in for compatibility. A stored timestamp almost never says which of these it is, so identifying the format is genuinely the harder half of the job — the arithmetic afterwards is one subtraction and one division.

The good news is that wrong guesses are loud. Because the epochs are separated by centuries, reading a value against the wrong one throws the date hundreds of years off rather than a little way off: a current FILETIME read as Unix nanoseconds lands in 1974, and a nanosecond value read as FILETIME lands somewhere past the year 7000. That is the whole basis of the detection here — compute every reading, discard the ones that produce an implausible century, and show what is left. It fails only when two epochs genuinely overlap for the value you have, which is why the alternatives stay visible instead of being resolved for you. When the value turns out to be an ordinary epoch integer and all you need is the unit and the zone, the epoch converter handles a whole pasted column of them at once.

The text formats have their own quiet trap, and it is the missing offset. ISO 8601 permits a local time with nothing after the seconds, SQL DATETIME columns store exactly that, and Excel cells have never held a zone in their lives — so all three describe a wall clock rather than a moment, and turning one into an instant requires a decision somebody has to make. Ninety per cent of the arguments about a timestamp being wrong by an hour come from that decision being made twice, differently, in two parts of the same system. Store an offset or store UTC; and when you just need the current value to test with, take it from the live timestamp counter rather than typing one out.

Where your value is read

Identification and conversion both happen inside this tab. The string you paste is examined by JavaScript on your own machine and never leaves it, which is worth knowing when the thing you are decoding is a document identifier or a row key lifted out of a production database. Nothing is uploaded, nothing is retained, and reloading the page clears it.