Timestamp Converter

Convert between Unix timestamps, ISO 8601, and human-readable date formats.

What does Timestamp Converter do?

This actor converts timestamps between Unix seconds, Unix milliseconds, ISO 8601, and human-readable formats. It also extracts date components (year, month, day, hour, minute, second, day of week) from each input. Accepts a wide range of input formats including numeric Unix timestamps, ISO 8601 strings, and natural date strings like "March 1, 2026". Useful for data pipeline transformations, log analysis, and bulk date conversions.

Use cases

• Data engineer normalizing mixed timestamp formats from multiple data sources into a consistent ISO 8601 format
• Backend developer converting Unix timestamps from APIs into human-readable dates for reports or dashboards
• QA engineer verifying that date fields in API responses are correct by cross-referencing multiple formats
• DevOps engineer converting server log timestamps for correlation across systems with different time formats
• Analyst extracting day-of-week or month components from dates for time-series analysis

Why use Timestamp Converter?

• Multiple input formats -- accepts Unix seconds, Unix milliseconds, ISO 8601, and natural language date strings in a single batch
• Complete output -- every input returns Unix seconds, Unix milliseconds, ISO 8601, human-readable, UTC string, and all date components
• Batch processing -- convert hundreds of timestamps in a single run instead of one at a time
• Validation built in -- invalid or unparseable timestamps are flagged with isValid: false and a descriptive error message
• Date component extraction -- get year, month, day, hour, minute, second, and day of week without additional processing
• Pay-per-event pricing -- only $0.0005 per timestamp converted, plus a one-time start fee

Input parameters

Parameter	Type	Required	Default	Description
timestamps	string[]	Yes	--	List of timestamps to convert. Accepts Unix seconds, Unix milliseconds, ISO 8601, or date strings.

{
    "timestamps": ["1709251200", "2026-03-01T00:00:00Z", "March 1, 2026"]
}

Output example

Each timestamp produces a result with all formats and date components:

Field	Type	Description
input	string	The original timestamp
isValid	boolean	Whether the input was parseable
unixSeconds	number	Unix timestamp in seconds
unixMilliseconds	number	Unix timestamp in milliseconds
iso8601	string	ISO 8601 formatted date
humanReadable	string	Human-readable date string
utcString	string	UTC date string
year, month, day	number	Date components
hour, minute, second	number	Time components
dayOfWeek	string	Day of the week name
error	string	Error message if conversion failed

{
    "input": "1709251200",
    "isValid": true,
    "unixSeconds": 1709251200,
    "unixMilliseconds": 1709251200000,
    "iso8601": "2024-03-01T00:00:00.000Z",
    "humanReadable": "Fri, 01 Mar 2024 00:00:00 GMT",
    "utcString": "Fri, 01 Mar 2024 00:00:00 GMT",
    "year": 2024, "month": 3, "day": 1,
    "hour": 0, "minute": 0, "second": 0,
    "dayOfWeek": "Friday",
    "error": null
}

How much does it cost?

Event	Price	Description
Start	$0.035	One-time per run
Timestamp converted	$0.0005	Per timestamp converted

Example costs:

• 10 timestamps = $0.035 + (10 x $0.0005) = $0.04
• 100 timestamps = $0.035 + (100 x $0.0005) = $0.085
• 1,000 timestamps = $0.035 + (1,000 x $0.0005) = $0.535

Using the Apify API

You can start Timestamp Converter programmatically from your own applications using the Apify API. Below are examples in Node.js and Python.

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('automation-lab/timestamp-converter').call({
    timestamps: ['1709251200', '2026-03-01T00:00:00Z'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run = client.actor('automation-lab/timestamp-converter').call(run_input={
    'timestamps': ['1709251200', '2026-03-01T00:00:00Z'],
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Integrations

Timestamp Converter works with the full Apify integration ecosystem. You can connect it to a wide range of automation platforms and data destinations:

• Make (formerly Integromat) -- trigger timestamp conversion as a step in a multi-tool scenario
• Zapier -- normalize date formats automatically as part of your zap workflows
• n8n -- use the Apify node in n8n workflows for self-hosted date processing pipelines
• Slack -- send converted timestamps to a Slack channel for team visibility
• Google Sheets -- export all date formats to a spreadsheet for review or analysis
• Amazon S3 -- store output datasets in S3 buckets for downstream data lake ingestion
• Webhooks -- send results to any HTTP endpoint for real-time date normalization

You can also schedule recurring runs on the Apify platform to process new timestamp data on a timer.

Tips and best practices

• Mix input formats freely -- you can include Unix timestamps, ISO 8601 strings, and natural language dates in the same batch. The actor auto-detects the format of each entry.
• Use isValid to filter results -- check this flag before using converted values downstream to avoid propagating bad data from unparseable inputs.
• Extract components for analysis -- use the dayOfWeek, month, or hour fields directly for time-series grouping without additional date parsing in your code.
• Be aware of time zones -- all output is in UTC. If your input contains timezone-aware strings, the actor converts them to UTC. For local time conversions, apply the offset in your downstream processing.
• Distinguish seconds from milliseconds -- Unix timestamps with 10 digits are interpreted as seconds, while 13-digit timestamps are interpreted as milliseconds.

FAQ

What timestamp formats are supported as input? The actor accepts Unix timestamps in seconds (10 digits) and milliseconds (13 digits), ISO 8601 strings (e.g., 2026-03-01T00:00:00Z), and common date strings (e.g., March 1, 2026, 2026/03/01).

Are all outputs in UTC? Yes. All converted timestamps are output in UTC regardless of the input timezone. If you need local time, apply your timezone offset to the Unix timestamp or ISO 8601 value in your own code.

What happens with ambiguous date strings? Ambiguous formats like 01/02/2026 (which could be January 2 or February 1 depending on locale) are parsed using JavaScript's Date constructor, which typically interprets them as month/day/year. For unambiguous results, use ISO 8601 or Unix timestamp input.

Can I convert timestamps to a specific timezone? All output is in UTC. The actor does not support timezone conversion directly. To get local time, take the unixSeconds or iso8601 value from the output and apply your desired timezone offset in your own code.

What is the valid range for Unix timestamps? The actor accepts any value that JavaScript's Date constructor can parse. In practice, this means dates from roughly 271,821 BCE to 275,760 CE. Timestamps outside this range will have isValid set to false.