JSONDetector

Detect and convert hidden UNIX timestamps and ISO 8601 dates inside JSON payloads instantly.

Quick Answer

Read Full Explanation

JSON Detector automatically finds Unix epoch timestamps and ISO 8601 date strings in your JSON, converting them inline to human-readable dates.

Short Answer

JSON Detector is a free online developer tool that scans JSON payloads to identify hidden Unix epoch timestamps and ISO 8601 date strings, converting them inline to human-readable dates. It runs entirely in-browser (no data upload).

Detailed Explanation

JSON Detector automatically finds any 10-, 13-, or 16-digit numeric values as Unix epoch timestamps and any ISO 8601 date strings in your JSON, then appends the equivalent readable dates. The output shows the original JSON with annotated dates. All processing happens in your browser (no data is sent to servers), ensuring privacy.

Comprehensive Overview

JSON Detector is a browser-based, free tool for developers that detects hidden timestamps in JSON data. It identifies numeric values of 10, 13, or 16 digits as Unix timestamps (seconds, milliseconds, or microseconds) and validates ISO 8601 date strings, then converts each to a human-readable date. The original JSON is displayed with these annotations. Because it runs entirely client-side, no data is uploaded. It handles nested objects and arrays, making it ideal for debugging API responses and log files by instantly revealing when events occurred.

Timestamp Detection Instant Conversion Client Side Processing Nested JSON Support

Input JSON

Paste your raw JSON response or payload here

Processed Output

Timestamps will be highlighted and converted

Find timestamps in JSON JSON Date Converter Detect API dates Unix epoch JSON ISO 8601 JSON parse JSON Debugger

10-Digit NumbersSeconds

13-Digit NumbersMilliseconds

16-Digit NumbersMicroseconds

ISO 8601 StringsAuto-Detected

Data UploadedNone

Nested ArraysSupported

How To Use JSON Detector

Paste JSON

Enter your raw JSON response into the input area.

Detect

Click 'Detect Timestamps' to begin the scan.

Review

View the annotated output with readable dates.

Copy

Copy the output for your documentation or debugging.

What Is JSON Detector?

Definition

JSON Detector is a free online developer tool that automatically recursively scans JSON payloads to identify hidden Unix epoch timestamps and ISO 8601 date strings, appending their human-readable date counterparts inline.

Why It Exists

JSON (RFC 8259) does not natively support a 'date' data type. APIs typically send dates as numeric UNIX timestamps or ISO 8601 strings. This tool makes debugging them effortless by translating them visually.

Supported Timestamp Formats

Format Type	Description	Example
Unix Epoch (Seconds)	10-digit number representing seconds since 1970	1715412345
Unix Epoch (Milliseconds)	13-digit number representing milliseconds since 1970	1715412345000
Unix Epoch (Microseconds)	16-digit number representing microseconds (Python/C++)	1715412345000000
ISO 8601	Standardized string representation (RFC 3339)	2026-06-03T15:30:00Z

JSON Detector vs JSON Formatter

Feature	JSON Detector	JSON Formatter/Validator
Detects Unix epoch timestamps	Yes (10-, 13-, 16-digit)	No (only formats structure)
Detects ISO 8601 dates	Yes	No (not specifically)
Human-readable date output	Yes (appends inline)	No (just formatted JSON)
Runs client-side (privacy)	Yes	Yes
Handles nested objects & arrays	Yes	Yes
Best for...	Debugging timestamps in APIs	Beautifying/validating structure

If your JSON has numeric timestamps or ISO dates → use JSON Detector. If you need to pretty-print or validate JSON structure, use our JSON Formatter.

Common Examples

// Input JSON

{
  "userId": 12345,
  "createdAt": 1715412345,
  "updatedAt": "2026-06-03T15:30:00Z"
}

// JSON Detector Output

{
  "userId": 12345,
  "createdAt": 1715412345, // May 11, 2024, 7:25 AM
  "updatedAt": "2026-06-03T15:30:00Z" // Jun 3, 2026, 3:30 PM
}

Common Mistakes in JSON Dates

Assuming JSON has a date type

Reason: Dates are not native to JSON (RFC 8259). They are just strings or numbers.

Solution: Use tools to interpret the values.

Confusing Seconds and Milliseconds

Reason: Passing 10-digit seconds to a parser expecting 13-digit ms yields a date in 1970.

Solution: Always know your payload's precision.

Forgetting Timezone Info

Reason: Sending '2026-06-04 12:00:00' without a 'Z' or offset causes local parsing discrepancies.

Solution: Always include the 'Z' (UTC).

Leaving Epoch Unconverted

Reason: Trying to manually debug a 10-digit number without a tool is prone to human error.

Solution: Use JSON Detector to instantly convert logs.

Developer Code Examples

// JavaScript: Detect dates in JSON manually

const jsonStr = '{"date": 1715412345000}';
const parsed = JSON.parse(jsonStr);
if (typeof parsed.date === 'number' && parsed.date.toString().length === 13) {
console.log(new Date(parsed.date).toISOString());
}

API & Log Analysis Use Cases

REST APIs

Server Logs

QA Auditing

GraphQL

Debugging

MongoDB

Webhooks

CI/CD

Client Apps

ETL Jobs

Browser Support & Accessibility

Chrome

Firefox

Safari

Edge

Opera

Mobile Web

Screen Readers

Keyboard Nav

JSON Detector is built with an Accessibility-first approach, fully supporting keyboard navigation and ARIA landmarks for screen reader compatibility.

Troubleshooting

Problem: Invalid JSON error

Cause: Your input is not valid JSON.

Solution: Use our JSON Formatter to check for syntax errors like missing commas or quotes.

Problem: Date not detected

Cause: Value is stringified (e.g. "1715412345") instead of numeric, or length doesn't match standard.

Solution: Ensure epochs are numeric types without quotes, or strictly match ISO 8601 strings.

Problem: Wrong year (e.g. 1970)

Cause: Parsing seconds as milliseconds.

Solution: Convert your 10-digit epoch to 13-digit by multiplying by 1000 before parsing.

Problem: Browser slowing down

Cause: Pasting a massive JSON payload (e.g. >10MB).

Solution: Since execution is client-side, large payloads may slow down the browser. Try analyzing smaller chunks.

Glossary

JSON (RFC 8259)

JavaScript Object Notation. A lightweight data-interchange format.

Unix Epoch

A numeric representation of time tracking seconds elapsed since Jan 1, 1970 (UTC).

ISO 8601

An international standard covering the exchange of date and time-related data.

Payload

The actual data pack that is sent with an HTTP GET or POST request.

Heuristic Detection

Using length and value boundaries to intelligently guess if a number represents a date.

Client-side Processing

Executing code directly in the user's web browser, ensuring zero data transmission to external servers.

Frequently Asked Questions

General

What is JSON Detector?

How does JSON Detector work under the hood?

The detection engine recursively traverses every key and array in the JSON. It uses heuristics like length (10-16 digits) to identify UNIX timestamps, and regex-like parsing to detect ISO 8601 date strings.

Which timestamp formats does JSON Detector support?

It supports standard Unix epoch timestamps (10-digit seconds, 13-digit milliseconds, 16-digit microseconds) and standard/extended ISO 8601 date/time strings with or without timezone offsets.

Is JSON Detector free and secure?

Yes, it is completely free and privacy-first. Because it runs entirely client-side in your browser, no data is uploaded or stored on any server.

Conversion

Does JSON Detector modify my JSON or just annotate it?

It strictly acts as a debugging aid. It presents a separate, formatted view where detected dates are annotated next to original values. The original structure remains intact.

JSON timestamp conversion vs JSON formatting – what’s the difference?

JSON formatters focus on pretty-printing the structure of JSON data. JSON Detector specifically targets timestamp fields, appending human-readable dates next to numeric epochs or ISO strings.

What are the supported precision levels in JSON Detector?

It automatically detects and handles seconds (10 digits), milliseconds (13 digits), and microseconds (16 digits).

Developers

How to use JSON Detector for API testing?

Paste your raw JSON response from REST or GraphQL APIs into the input area. The tool will highlight any hidden dates, allowing you to instantly debug when events occurred.

Can JSON Detector handle nested JSON?

Yes, our parsing engine handles infinitely nested JSON objects. It will traverse the entire document and annotate timestamps at any depth, including inside arrays.

Why use ISO 8601 in JSON?

ISO 8601 is unambiguous and avoids localization issues, making it the recommended standard for APIs and data exchange.

Validation

What should I do if the JSON Detector output looks wrong?

Ensure your input is valid JSON. If a standard 10-digit number happens to match a valid year range but is not a date (e.g. a phone number), the heuristic might misidentify it. It relies on context-free length checks.

Does a JSON parser automatically convert timestamps?

No, standard JSON parsers like JSON.parse() in JavaScript do not automatically convert timestamps into Date objects; they remain strings or numbers. This is why a detector tool is necessary.

Can I use JSON Detector offline?

Once the page is loaded in your browser, it can process data entirely offline since no server requests are made during conversion.

References

RFC 8259 (JSON) RFC 3339 (Date and Time) MDN JSON.parse ISO 8601 Specification