⚙️ Settings
Epoch Converter — Unix Timestamp to Date Converter
The Epoch Converter converts Unix timestamps to human-readable dates, and dates back into Unix timestamps, in both UTC and your local timezone. It's built for developers and QA engineers who need to convert Unix timestamp to date while debugging logs, inspecting API responses, or working with any system that stores time as epoch seconds. Enter a timestamp or a date, and get the conversion instantly.
⚡ Key Takeaways
- Converts Unix timestamps to dates, and dates back into timestamps, both directions.
- Shows results in UTC and your local timezone side by side.
- A timestamp that looks thousands of years off is usually in milliseconds, not seconds.
- The "Now" button instantly inserts the current timestamp for quick reference.
What, Who, When & Why
| What it's for | Converts Unix timestamps to human-readable dates, and dates back into timestamps, in UTC and your local timezone. |
|---|---|
| Who it's for | Developers and QA engineers debugging logs, APIs, or databases that store time as epoch seconds. |
| When to use it | Whenever you encounter a raw timestamp number in a log, database row, or API response and need to know the actual date. |
| Why it's needed | Unix timestamps are unreadable at a glance, and manually calculating a date from a raw second count isn't practical. |
| Best way to use it | If a converted date looks thousands of years off, check whether your source value is in milliseconds rather than seconds and divide by 1,000 first. |
How to Use the Epoch Converter
- Enter a Unix timestamp into the timestamp field to convert it to a readable date, or enter a date to convert it to a Unix timestamp.
- Click Now to instantly fill in the current Unix timestamp.
- Results show both the UTC and your local timezone equivalent.
- Click Copy to grab the converted result.
What Is a Unix Timestamp?
A Unix timestamp (also called epoch time) is the number of seconds that have elapsed since January 1, 1970, 00:00:00 UTC — a reference point known as "the Unix epoch." It's a common way for computer systems to store and compare dates and times as a single number, independent of timezone or calendar formatting, which makes it easy to sort, compare, and calculate durations between dates.
Example
The Unix timestamp 1700000000 converts to November 14, 2023, 22:13:20 UTC. This kind of conversion is essential when debugging a system where timestamps appear as raw numbers in logs, database rows, or API responses instead of readable dates. Converting a specific date back the other direction — say, checking what timestamp corresponds to the start of a particular day — is just as common when writing a query filter that needs an epoch value.
Key Features
- Converts Unix timestamps to human-readable dates.
- Converts human-readable dates back into Unix timestamps.
- Shows results in both UTC and your local timezone.
- "Now" button instantly inserts the current timestamp.
- Displays results in seconds and milliseconds.
Practical Use Cases
- Debugging logs: convert raw timestamp values in error logs or server logs into readable dates.
- Inspecting API responses: many APIs return timestamps as epoch seconds — convert them to confirm the actual date and time.
- Database queries: convert a specific date into a Unix timestamp for a query filtering on a stored epoch column.
- Scheduling and expiration checks: confirm exactly when a token or session with a Unix timestamp expiration will expire.
- Cross-timezone coordination: confirm what a UTC timestamp actually means in your own local time.
Tips for Best Results
- If your converted date looks wildly off (thousands of years in the future or past), your source value is likely in milliseconds rather than seconds — divide by 1,000 first.
- Use the "Now" button as a quick reference point when you need to compare a stored timestamp against the current time.
- When coordinating across timezones, always double-check the UTC value first, since that's the unambiguous reference point regardless of where each person is located.
Related Terminology
Epoch time and Unix timestamp refer to the same thing: seconds since January 1, 1970 UTC. UTC (Coordinated Universal Time) is the time standard used as the reference for timestamps worldwide, independent of any specific timezone, which is why converting to your local timezone is a separate, additional step. Some systems use milliseconds since the epoch instead of seconds, which is 1,000 times larger than the standard second-based timestamp.
Important Considerations
Some systems use milliseconds since the epoch instead of seconds — if your converted date looks wildly incorrect (thousands of years off), check whether your source value is actually in milliseconds and needs dividing by 1,000 first. Timezone conversions depend on your device's current timezone setting, so the "local" result will differ if you check it from a different location or device.
Related Tools
Need to generate a sequence of dates rather than convert a single timestamp? Try the Date Range Generator. To calculate time remaining until a specific date, use Time Till.
Frequently Asked Questions
How do I convert a Unix timestamp to a date?
Enter the timestamp into the input field — the corresponding date and time appears instantly in both UTC and your local timezone.
What is epoch time?
Epoch time (or Unix timestamp) is the number of seconds elapsed since January 1, 1970, 00:00:00 UTC — a standard reference point used by many computer systems to represent dates and times as a single number.
Why does my converted date look thousands of years off?
Your source timestamp is likely in milliseconds rather than seconds — divide it by 1,000 before converting, since Unix timestamps are traditionally measured in seconds.
Does the local time shown depend on my device's timezone setting?
Yes, the local timezone conversion is based on your device's current timezone — the UTC value is the unambiguous reference point if you need to compare across different locations.
WITH recent_orders AS (
SELECT
customer_id,
order_id,
order_date,
total_amount
FROM orders
WHERE order_date >= DATEADD(day, -30, GETDATE())
)
SELECT
customer_id,
COUNT(order_id) AS order_count,
SUM(total_amount) AS total_spent
FROM recent_orders
GROUP BY customer_id
ORDER BY total_spent DESC;
WITH RECURSIVE employee_hierarchy AS (
-- Anchor: top-level rows (no manager)
SELECT
employee_id,
manager_id,
employee_name,
1 AS level
FROM employees
WHERE manager_id IS NULL
UNION ALL
-- Recursive: join children to their parent's result
SELECT
e.employee_id,
e.manager_id,
e.employee_name,
eh.level + 1
FROM employees e
INNER JOIN employee_hierarchy eh
ON e.manager_id = eh.employee_id
)
SELECT *
FROM employee_hierarchy
ORDER BY level, employee_name;
-- Note: SQL Server / Oracle: drop the RECURSIVE keyword (just WITH employee_hierarchy AS (...))
SELECT
o.order_id,
c.customer_name,
o.order_date,
p.product_name,
oi.quantity
FROM orders o
INNER JOIN customers c
ON o.customer_id = c.customer_id
LEFT JOIN order_items oi
ON o.order_id = oi.order_id
LEFT JOIN products p
ON oi.product_id = p.product_id
WHERE o.order_date >= '2026-01-01'
ORDER BY o.order_date DESC;
SELECT
DATE_TRUNC('month', order_date) AS order_month, -- PostgreSQL
-- FORMAT(order_date, 'yyyy-MM') AS order_month, -- SQL Server
-- DATE_FORMAT(order_date, '%Y-%m') AS order_month, -- MySQL
COUNT(*) AS order_count,
SUM(total_amount) AS revenue
FROM orders
GROUP BY DATE_TRUNC('month', order_date)
ORDER BY order_month;
SELECT
customer_id,
order_id,
order_date,
total_amount,
ROW_NUMBER() OVER (
PARTITION BY customer_id
ORDER BY order_date DESC
) AS order_rank,
SUM(total_amount) OVER (
PARTITION BY customer_id
ORDER BY order_date
ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
) AS running_total
FROM orders;
CREATE PROCEDURE GetCustomerOrders
@CustomerId INT,
@StartDate DATE = NULL,
@EndDate DATE = NULL
AS
BEGIN
SET NOCOUNT ON;
SELECT
order_id,
order_date,
total_amount
FROM orders
WHERE customer_id = @CustomerId
AND (@StartDate IS NULL OR order_date >= @StartDate)
AND (@EndDate IS NULL OR order_date <= @EndDate)
ORDER BY order_date DESC;
END;
-- Call it: EXEC GetCustomerOrders @CustomerId = 101, @StartDate = '2026-01-01';
MERGE INTO customers AS target
USING staging_customers AS source
ON target.customer_id = source.customer_id
WHEN MATCHED THEN
UPDATE SET
target.customer_name = source.customer_name,
target.email = source.email,
target.updated_at = GETDATE()
WHEN NOT MATCHED THEN
INSERT (customer_id, customer_name, email, created_at)
VALUES (source.customer_id, source.customer_name, source.email, GETDATE());
#FACC15
rgb(250, 204, 21)
rgb(98%, 80%, 8%)
hsl(46, 96%, 53%)
hsv(46, 92%, 98%)
cmyk(0%, 18%, 92%, 2%)
Tools for analysts, developers & QA engineers
33 free, browser-based utilities — text and list tools, SQL helpers, converters, and small productivity apps. Everything runs locally; nothing you type or paste is ever uploaded.
For Analysts
Clean lists, build SQL fragments, and reshape data without opening a spreadsheet.
For Developers
Format SQL, convert data formats, and handle everyday text and encoding tasks.
For QA Engineers
Generate test data, compare text output, and sanitize queries before sharing them.