Unix seconds to ISO 8601
Paste a Unix timestamp in seconds and get the exact UTC date and time in ISO 8601: 1800000000 becomes 2027-01-15T08:00:00Z. Negative values before 1970 and fractions of a second work too. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Seconds
- 1,800,000,000
- Year
- 2,027
- Month
- 1
- Day
- 15
- Hour
- 8
A Unix seconds to ISO 8601 converter answers a daily engineering question: given an epoch count such as one billion eight hundred million, what is the exact UTC calendar datetime that logs, APIs, and databases should display? Enter a finite number of seconds since 1970-01-01T00:00:00Z and this tool splits the value into a whole UTC day and a time of day, maps the day offset to a proleptic Gregorian year-month-day with a published civil-from-days algorithm, and returns a deterministic ISO 8601 string ending in Z. Fractional seconds are accepted and written with trimmed fractional digits when needed.
What a Unix second count means and why ISO 8601 is the safe display form
Unix time counts seconds since midnight UTC on 1 January 1970, a simple integer (or real) timeline that machines exchange without locale separators, month names, or daylight-saving rules. That simplicity is why log lines, JWT claims, database columns, and message queues store moments as epoch seconds. Humans still need a calendar face: year, month, day, hour, minute, and second in a string that parsers agree on worldwide.
ISO 8601 with a Z suffix is that face for UTC—YYYY-MM-DDTHH:mm:ssZ—unambiguous across languages and spreadsheets. Converting correctly is not optional trivia during an outage: misreading a timestamp by twelve hours can send the wrong postmortem window or the wrong retention purge. This capability computes the civil date with pure proleptic Gregorian arithmetic from the day index floor(seconds divided by 86400), then builds the clock fields from the non-negative remainder.
Negative timestamps are first-class: one second before the epoch is 1969-12-31T23:59:59Z, not an error. The mapping never consults the server clock, so the same number always yields the same string in tests and production. Prefer this landing when your search intent is specifically Unix seconds to ISO 8601 in UTC, not a bidirectional multi-unit epoch playground and not a local-timezone wall clock.
Practical tips, limits, and how this differs from related tools
Keep a small known set for teaching and CI: zero maps to 1970-01-01T00:00:00Z; one billion eight hundred million maps to 2027-01-15T08:00:00Z; negative one maps to 1969-12-31T23:59:59Z; and one deliberate non-numeric failure. When a vendor sends epoch milliseconds, divide by one thousand before calling so the second field stays on the Unix-seconds contract. Document that output is always UTC with a Z suffix—there is no local offset, no named timezone database, and no daylight-saving branch—so dashboards that need city-local display should apply their own offset after this conversion.
Year bounds are one through nine thousand nine hundred ninety-nine after conversion; extreme values that fall outside that civil window are rejected rather than formatted with overflow. This landing targets people searching for Unix seconds to ISO 8601, epoch to ISO datetime, or a free Unix timestamp to UTC string converter. It is not a bidirectional epoch converter that also turns dates back into integers, not an NTP second converter, not a humanize-duration tool, and not a spreadsheet serial-date mapper.
Prefer this capability when you already have a second count and only need the ISO UTC string; if you need both directions or millisecond toggles on one form, use a general epoch converter instead.
What you can do with it
Incident log triage in UTC
Paste a raw Unix second value from a stack trace or log line and get a deterministic ISO 8601 UTC string for the postmortem timeline.
ETL normalization of vendor epochs
Data pipelines convert mixed second-based epoch columns into ISO 8601 strings before warehouse loads and audit exports.
FAQ
How do I convert Unix seconds to an ISO 8601 datetime?
Send a finite seconds value (Unix epoch seconds since 1970-01-01T00:00:00Z).
Is the result in local time or UTC?
Always UTC. The iso string ends with Z and timezone is the constant UTC. No local offsets or named time zones are applied.
Can I pass milliseconds instead of seconds?
Not directly. This tool expects seconds. Divide milliseconds by 1000 before calling so the unit stays unambiguous.
What happens with a missing or non-numeric value?
Missing, empty, non-finite, or non-numeric input is rejected rather than coerced to zero.
Is the Unix seconds to ISO 8601 converter free?
The browser tool is free and runs locally.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/date/unix-seconds-to-iso \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"seconds":1800000000}'const res = await fetch("https://api.kit.forhosting.com/date/unix-seconds-to-iso", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"seconds": 1800000000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/date/unix-seconds-to-iso",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"seconds": 1800000000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/date/unix-seconds-to-iso", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"seconds":1800000000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"seconds":1800000000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/date/unix-seconds-to-iso", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"seconds": 1800000000
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "date.unix_seconds_to_iso",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
Missing or non-finite input is rejected with invalid_input rather than silently coerced to zero, because an empty epoch is a data error, not midnight on the Unix epoch.
How to call the API and what the response contains
String numbers that match a strict finite numeric pattern are accepted when forms or query strings force text. Prefer asserting the iso string and the echoed components in automated tests rather than re-deriving calendar math by hand in every client. Milliseconds must be converted by the caller (divide by one thousand) because this contract is seconds-only; that keeps the SEO intent tight and avoids silent unit mistakes. POST a JSON body with the required field seconds set to a finite number (whole or fractional). Aliases unix, epoch, ts, timestamp, and unix_seconds are accepted for ergonomics and are coerced the same way as seconds. On success the response echoes seconds as the coerced number, year, month, day, hour, minute, and second as the UTC civil components, iso as the ISO 8601 string with a Z designator, timezone as the constant UTC, formula as the fixed identity description, and message as a one-line summary. Failed validation—missing field, non-finite values, non-numeric strings, or a civil year outside 0001–9999—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item.
Practical tips, limits, and how this differs from related tools
Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when learners deliberately send garbage strings.
Integration use cases
Unit-test fixtures for time APIs
Engineering teams pin iso for known second inputs so client and server datetime formatting never disagree across runtimes.