Paste a column of Unix timestamps, one per line, and the converter returns each row as an ISO 8601 / RFC 3339 string in UTC. Each row is auto-detected as seconds or milliseconds based on digit count, so a mixed column from a database export, a CloudWatch dump, or a Stripe webhook log all converts in one paste. A bad row surfaces an inline error and the rest of the batch keeps going. Use this for log correlation, database backfills, and audit trails when you have many epoch values to read at once. For a paste of ISO calendar dates instead, use the batch date calculator.
Common use cases
- Correlate log lines across services. Application logs in seconds, CloudWatch in milliseconds, and a vendor webhook in seconds again. Paste all three columns in one batch and the auto-detect rule resolves each row independently, so the ISO outputs line up for grep or a spreadsheet pivot without per-row format toggles.
- Backfill a database column. A Postgres timestamp column stores epoch seconds and you need an ISO version for a reporting view. Export the column, paste it here, copy the result back as the source for an UPDATE statement. The CSV output keeps the original input alongside the ISO string for audit.
- Verify a JWT or session export. A list of "iat" or "exp" claims pulled from an audit table is just integers. Paste the column to see which sessions started in 2024 and which expired before a known incident, without parsing each value in a JavaScript console.
- Cross-check a vendor data dump. A CSV from a third party mixes seconds and milliseconds across rows and the schema does not say which is which. Paste the timestamp column and read the ISO column to spot rows that resolve to absurd dates, then flag those for the vendor.
- Audit a deploy timeline. Build, push, and rollout events from CI emit epoch values in different units. Paste the merged list to read the deploy sequence as ISO instants, then run the result through the timezone converter to compare against on-call wall-clock time.
How it works
The converter splits the textarea on newlines, trims each line, and runs every non-empty line through the same epoch parser used by the single-value form. Auto mode picks seconds or milliseconds per row by digit count: thirteen or more digits parses as milliseconds, fewer as seconds. Each row returns either an ISO string or an inline error, with line numbers preserved so the output rows match the input rows exactly.
- Paste the timestamp column. One Unix timestamp per line. Positive integers, negative integers, and decimals all parse. Empty lines and trailing whitespace are tolerated; the trim runs before parsing.
- Pick the unit mode. Leave it on auto and each row is detected independently. Switch to "all seconds" or "all milliseconds" when you know every row uses the same unit and you want to override the digit-count rule.
- Read the result table. Each row renders the line number, the original input, and either the ISO UTC string or an error message. The table updates live as you type, so there is no submit button to press.
- Copy the CSV output. The CSV box pairs every input with its ISO output and any error, in the original line order. Paste it back into a spreadsheet, a SQL CASE expression, or a Jira ticket as evidence.
Worked examples
Mixed seconds and milliseconds in one paste
Paste 1704067200 on line 1 and 1704067200000 on line 2 with auto-detect on.
Result: Line 1 returns 2024-01-01T00:00:00.000Z. Line 2 also returns 2024-01-01T00:00:00.000Z.
The same instant in two different units. The ten-digit row routes through seconds parsing and the thirteen-digit row routes through milliseconds parsing, so the ISO outputs collapse to the identical UTC instant.
Invalid row mixed with valid timestamps
Paste 1704067200, then "foo", then 0 on three lines with auto-detect on.
Result: Line 1 returns 2024-01-01T00:00:00.000Z. Line 2 returns the error "Enter a numeric Unix timestamp." Line 3 returns 1970-01-01T00:00:00.000Z.
The bad row stays in the output as an inline error rather than aborting the batch. Lines 1 and 3 are unaffected, so a single malformed entry never costs you the full conversion.
Negative timestamp before the epoch
Paste -86400 with auto-detect on.
Result: The row returns 1969-12-31T00:00:00.000Z.
Negative values represent instants before 1970-01-01. Useful for archival systems and historic event tables that backdate beyond the Unix epoch.
Year 2025 in milliseconds
Paste 1735689600000 with auto-detect on.
Result: The row returns 2025-01-01T00:00:00.000Z.
Thirteen digits triggers millisecond parsing. The same instant in seconds is 1735689600, which would also resolve correctly on its own row.
Edge cases & gotchas
- Auto-detect uses digit count, not magnitude. The detector checks the integer-part length after stripping the sign and decimal. A 12-digit value parses as seconds even though some APIs emit 12-digit milliseconds for instants before 2001-09-09. Override the unit mode to "all milliseconds" when you know the source uses millisecond precision but produces shorter values.
- Bad rows do not abort the batch. A row that fails the numeric check returns "Enter a numeric Unix timestamp." in its result cell and the rest of the batch keeps converting. Output row count always matches input row count, including blank lines and rejected entries, so the line numbers in the result line up with the source list.
- No upper row cap. The converter splits on newlines and processes every row in a single synchronous pass. There is no built-in limit, so a thousand rows convert in one paste. Browser memory and clipboard size are the practical ceiling, not the calculator. Very large pastes may freeze the textarea briefly while React rerenders the result table.
- Microsecond and nanosecond values overflow. A 16-digit microsecond value like 1704067200000000 trips the millisecond branch and resolves to a date in year 55969 instead of 2024. The converter has no microsecond or nanosecond mode. Divide your source by 1000 (microseconds) or 1000000 (nanoseconds) before pasting.
Frequently asked questions about Bulk Timestamp Converter
How does the auto-detect rule work?
Per row, the converter strips the sign, splits on the decimal point, and counts the digits in the integer part. Thirteen or more digits parses as milliseconds, fewer parses as seconds. Each row is decided independently, so a mixed column converts in one paste.
What happens when a row fails to parse?
That row returns "Enter a numeric Unix timestamp." in its result cell and the rest of the batch keeps converting. The output row count matches the input row count, so the surviving rows stay aligned with the source list for paste-back into a spreadsheet.
Can I paste seconds and milliseconds in the same column?
Yes. Auto mode resolves each row independently by digit count, so a CloudWatch milliseconds value and a Postgres seconds value can sit on consecutive lines and both convert correctly. Use the explicit unit modes only when you want to force one interpretation across every row.
Are negative timestamps supported?
Yes. Negative values resolve to instants before 1970-01-01. The ECMAScript Date object covers roughly 271821 BC through 275760 AD, which is far wider than any practical archival range, so historic and backdated entries convert without truncation.
Is there a limit on how many rows I can paste?
No row cap is built in. The converter runs every line through the same parser in one pass. A thousand rows convert without trouble; the practical ceiling is browser memory and clipboard size rather than the calculator itself.
How do I convert microseconds or nanoseconds?
The converter only knows seconds and milliseconds. A 16-digit microsecond value parses as milliseconds and resolves to a far-future date. Divide your source values by 1000 for microseconds or 1000000 for nanoseconds before pasting.
How is this different from the single-value converter?
The single-value converter takes one timestamp and returns one ISO string, faster for a one-off lookup. This bulk version takes a paste of many values and returns a result table plus a CSV column, faster for log correlation, database backfills, and audit trails.
Glossary
- Auto-detect (per row)
- A digit-count rule applied to each row independently. Thirteen or more digits in the integer part parses as milliseconds; fewer parses as seconds. Lets a mixed column convert in one paste.
- Per-row error
- An error string returned in a single output row when its input is not a numeric timestamp. The rest of the batch keeps converting; the row count of the output matches the input.
- CSV output
- A four-column comma-separated text block (line, input, iso, error) suitable for paste-back into a spreadsheet or a database load. Quoted to escape commas and quotes inside cells.
- Unix epoch
- The reference instant 1970-01-01T00:00:00Z from which Unix timestamps are counted. Defined in IEEE Std 1003.1 (POSIX) and shared by Linux, macOS, BSDs, and most server runtimes.
- RFC 3339
- The IETF profile of ISO 8601 used by most internet protocols. Output rows from this converter conform to RFC 3339 with millisecond precision and a trailing Z for UTC.