ForHosting KIT · Developer Utilities

Convert a Unix timestamp

Every log line, database row and API payload eventually needs its epoch number turned into something a person can read, or the reverse. This unix timestamp converter API takes either direction in a single call, so a debugging session or a data pipeline never has to pause for manual math.

● StableFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailApp soonTelegram soon

The number that means nothing until it's translated

A Unix timestamp like 1752451200 is precise and unambiguous to a machine but says nothing to a human glancing at a support ticket, a log file or a spreadsheet export. Engineers triaging an incident, analysts auditing a report, and support teams reading raw API responses all hit the same wall: the timestamp is correct, but nobody can tell at a glance whether it means this morning or three weeks ago. Converting it correctly, including the right timezone, is the difference between a five-second glance and a five-minute detour into a script.

One endpoint, both directions

POST /dev/epoch accepts either an epoch value to turn into a formatted date or a date string to turn into epoch seconds (or milliseconds), with an optional timezone or UTC offset applied to the output. The task is queued asynchronously and returns a task_id right away; the converted value arrives moments later via signed webhook or a signed link valid for 24 hours, ready to drop into a log viewer, a report or a downstream request.

A convention older than most of the software using it

Unix time counts seconds since midnight UTC on January 1, 1970, a convention chosen by early Unix developers for its simplicity rather than any special significance of that date. It has since become the default way computers exchange moments in time internally, precisely because it avoids the ambiguity of formatted dates, no locale, no separators to misparse, just a count. The tradeoff is that the format is unreadable to people, which is exactly the gap this endpoint closes on demand.

Where it earns its keep in a pipeline

Log processors, ETL jobs and support dashboards all pass timestamps around constantly, and hardcoding timezone-aware date parsing into every one of those systems is brittle and easy to get wrong across daylight saving boundaries. Calling a dedicated conversion endpoint keeps that logic in one place, consistent whether the request comes from a nightly batch job or an on-call engineer pasting a single value during an incident. At $0.002 per request, converting a batch of timestamps costs a fraction of a cent per entry.

Access, pricing and what happens to the data

Using the endpoint requires prepaid balance; without one, the request returns HTTP 402 rather than a degraded or partial answer, and a failed conversion is never billed after its automatic retries. Pricing is a flat $0.002 per request regardless of direction. The endpoint is live now, and the timestamps sent through it are discarded after the delivery window, never retained for training or analysis.

What you can do with it

Incident debugging

Paste a raw epoch value from a stack trace or log line and get back a readable local date in seconds, no mental math during an outage.

Data pipeline normalization

Convert mixed timestamp formats coming from different vendors into consistent epoch seconds before loading them into a warehouse.

Scheduling and reporting UI

Turn stored epoch values into timezone-correct display dates for a dashboard without embedding date libraries in the frontend.

API payload construction

Convert a human-entered date into the epoch value a third-party API expects, avoiding manual offset calculations.

FAQ

How does this unix timestamp converter API work?

Send an epoch value or a date string to POST /dev/epoch and it returns the converted value in the opposite format, with the result delivered by webhook or a signed link.

Can it convert a date back into a Unix timestamp?

Yes, the same endpoint accepts a date string and returns the corresponding epoch seconds or milliseconds.

Does it handle timezones?

Yes, you can specify a timezone or UTC offset and the output date reflects it correctly.

Is there a free tier for this API?

The tool above runs free in your browser. The API is paid — each call draws from your prepaid ForHosting KIT balance: top up from $10.00 (it never expires), pay each request's published price, and a call with no balance returns HTTP 402. No subscription, no tokens, and a failed task is never charged.

What does the epoch conversion API cost?

It costs a flat $0.002 per request no matter which direction you're converting.

Does it support milliseconds as well as seconds?

Yes, both epoch seconds and epoch milliseconds are accepted and can be requested as output.

Is the epoch converter endpoint live?

Yes, it is live now and accepting requests.

Can I convert timestamps in bulk?

Submit one request per value; each is queued and priced independently, so a batch can be processed through repeated calls to the same endpoint.

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

POSThttps://api.kit.forhosting.com/dev/epoch

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, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/dev/epoch \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"items":["valor-1","valor-2"]}'

const res = await fetch("https://api.kit.forhosting.com/dev/epoch", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "items": [
      "valor-1",
      "valor-2"
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/epoch",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "items": [
        "valor-1",
        "valor-2"
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/epoch", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"items":["valor-1","valor-2"]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"items":["valor-1","valor-2"]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/epoch", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "items": [
    "valor-1",
    "valor-2"
  ]
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.epoch",
  "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

Per request$0.002

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.

Read the full KIT documentation →

Run — free