Skip to content

iOS Timeline Analysis: iLEAPP, APOLLO and Time Formats

Build an iPhone timeline: Cocoa, Unix and nanosecond epochs, time zones, merging iLEAPP, APOLLO and sysdiagnose output, deduplication and validation.

Published on 9 min read

Almost every iPhone case ends as a timeline: messages, calls, app use, locations, photos and device state placed on one UTC axis, each row pointing back to its source. The difficulty is not building a long list of events; tools do that. It is making sure every time is converted correctly, every row belongs to this device, duplicates are removed, and the result is tested against reality.

This guide covers iOS time formats, the tools that produce timeline data, how to merge their output, and how to validate and present the result.

iOS time formats

FormatDefinitionConvert to Unix secondsWhere you meet it
Cocoa time, secondsSeconds since 2001-01-01 00:00:00 UTC+ 978307200Core Data stores: knowledgeC, Photos, CallHistory, AddressBook, routined, WhatsApp, Screen Time, Accounts3
Cocoa time, nanosecondsNanoseconds since 2001-01-01 UTC/ 1e9 + 978307200sms.db date columns
Cocoa time, floating pointSeconds with fraction+ 978307200Biome SEGB headers, some plists
Unix secondsSeconds since 1970-01-01 UTCnoneTCC.db, PowerLog (after offset), shutdown.log, Telegram
Unix millisecondsMilliseconds since 1970/ 1000Signal, many third-party apps
Plist dateBinary plist date (Cocoa-based)parsers show UTCConfiguration plists, Wi-Fi, app metadata
Local textDate and time as textneeds the device time zonemobile_installation.log, some app logs
Local text with offsete.g. +0200apply the stated offsetCrash reports, sysdiagnose file names

Recognise formats by magnitude. In 2026, Cocoa seconds are around 8.1 × 10^8, Unix seconds around 1.8 × 10^9, Unix milliseconds around 1.8 × 10^12, and Cocoa nanoseconds around 8.1 × 10^17. A result in 1970, around 1995 (Cocoa read as Unix) or around 2057 (Unix read as Cocoa) usually means a unit or epoch error. See Mac Absolute Time.

-- the three conversions you will use most in sqlite3
SELECT datetime(:cocoa_s + 978307200, 'unixepoch');
SELECT datetime(:cocoa_ns / 1000000000 + 978307200, 'unixepoch');
SELECT datetime(:unix_ms / 1000, 'unixepoch');

For one-off checks, a converter such as DCode shows a value in many formats at once, which helps identify an unknown epoch.

Time zones and clocks

  • Work in UTC. Nearly all database values are UTC. Convert to local time only in the final presentation, and say which zone you used.
  • Record the device's zone and changes. knowledgeC ZSECONDSFROMGMT, the Biome Device.TimeZone stream and PowerLog time zone tables record the offset in effect at the time. Travel changes it.
  • Record the device clock offset at seizure against a reference clock. If the device clock was wrong, all device-stamped events share the error.
  • Correct internal clocks. PowerLog's timestamps need the PLStorageOperator_EventForward_TimeOffset correction; raw values can be wrong by weeks.
  • Set the examiner's machine to UTC when using tools that print local time, such as log show on a sysdiagnose.

The tools

iLEAPP

iLEAPP runs hundreds of modules over a full file system extraction, a backup or packed sysdiagnoses and writes HTML and TSV reports per artifact, plus timeline output for modules that support it. Its strength is breadth and the notes each module carries about what was validated. Note the version you ran: modules change often.

APOLLO

APOLLO (Apple Pattern of Life Lazy Output'er) is a set of SQL modules, each with metadata naming the database, the supported versions and the key timestamp, and a runner that executes them over a folder of databases and merges the results into one CSV or SQLite timeline. It covers knowledgeC, PowerLog, routined, Screen Time, DataUsage, netusage, interactionC and more. Its modules are tagged for older releases (up to iOS 14 in the metadata), so on current devices, run them, then check which returned rows and verify the queries against the actual schema. The module files are also excellent reference queries for your own SQL.

sysdiagnose tooling

The EC-DIGIT-CSIRC sysdiagnose framework parses a sysdiagnose into JSONL files with timestamp and datetime fields and has a timesketch analyser that writes a Timesketch-ready timeline. Unified logs come from log show or macos-UnifiedLogs. See the sysdiagnose guide.

Plaso and viewers

Plaso includes parsers and SQLite plugins for a number of iOS sources and can process a file system extraction into a super timeline; check its parser list for your sources. For review, Timesketch handles large collaborative timelines, and Timeline Explorer is a fast viewer for CSV exports on Windows.

Commercial suites

Cellebrite, Magnet AXIOM and others build timelines across their decoded artifacts. They are fast and broad; export their data with source paths so it can be merged and checked like any other source.

Merging sources

A merged timeline needs a common schema. A minimal one:

ColumnExample
utc2026-09-12T21:04:17Z
local2026-09-12T23:04:17+02:00
eventmessage sent, app in focus start, visit entry
detailBundle ID, handle, coordinate with radius
sourcesms.db, Biome App.InFocus, Local.sqlite
locatorTable and primary key, SEGB file and offset, log line
devicethis, or the remote device ID for synced rows
toolTool and version that produced the row

Rules:

  1. Keep provenance on every row. Without source and locator, nobody can verify an event.
  2. Tag device attribution. Biome remote records, routined Cloud-V2.sqlite, Screen Time cloud data and synced iMessages can describe other devices.
  3. Deduplicate deliberately. The same event can come from the live database, its WAL, a sysdiagnose copy and an older archive. Deduplicate by source key, not by time alone, and keep a count of copies.
  4. Keep intervals as intervals. App focus and visits have start and end. Do not reduce them to single points.
  5. Do not fill gaps. A period with no events is a finding only if the sources covering it are known to be complete. Otherwise, say that coverage is missing.

Validation

  • Anchor events. The acquisition itself appears in many sources (pairing, backup, sysdiagnose trigger). Your own actions are a free validation of the clock and the offsets.
  • Test on a reference device. For any stream you rely on, perform a known action on a device of the same model family and iOS build and check how it appears.
  • Cross-source agreement. A message sent should coincide with Messages in focus and, often, with an interactionC record. A photo capture should coincide with Camera in focus and a PowerLog camera event. Seconds of difference are normal; minutes suggest a conversion problem.
  • External records. Carrier records, server logs, CCTV and the other party's device are independent clocks.

Choosing time windows

A timeline of everything is unreadable, and filtering too early hides context. A practical approach is to work in three rings:

  1. The core window: the minutes or hours the case turns on (an incident, a collision, an alleged meeting). Include every source, every row.
  2. The context window: the day before and after. Include device state, locations, communications and app focus, to show what was normal for this device.
  3. The baseline: the full retention period of the main sources, summarised (for example, typical unlock times, typical locations at that hour). It lets you say whether the core window was unusual.

Keep the filters you applied in the notes, so that another analyst can rebuild the same view from the merged data.

Presenting the timeline

Keep the report timeline short: the events that answer the questions, each with source and confidence. Put the full merged timeline in an annex or a spreadsheet. Show intervals as bars, locations with their radius, and state in one line which sources were examined and which were not reachable at the acquisition level you had.

Clock anomalies

Users and malware can change the device clock, and so can the network. Signs worth checking when events look out of order:

  • Time changes. Turning off automatic date and time and setting a manual time shifts every device-stamped event. PowerLog's time offset table records system clock corrections, and unified logs record time changes when they are still available. A sudden jump in the offset is a lead.
  • Sequence versus time. Core Data primary keys (Z_PK) and SQLite ROWID values usually increase with insertion. A row with a higher key but an earlier timestamp than its neighbours deserves a look: it may be a synced row, an imported item or a clock change.
  • Sender versus receiver clocks. Messages carry the sender's timestamp in several apps (Signal, WhatsApp to some extent). A received message stamped before the previous sent one is usually the other device's clock, not tampering.
  • Download versus observation. Cache tables stamp rows when data was downloaded, not when a place was visited. Photos imported from another camera carry that camera's clock.
  • Boot sessions. Biome Device.BootSession and shutdown.log SIGTERM times give reboots. An event claimed during a period when the device was off is impossible.

Document every anomaly you checked, even if it turned out benign. It shows the reviewer that the timeline was tested.

A minimal case workflow

  1. Build the device profile sheet (identity, build, time zone, clock offset, acquisition levels).
  2. Run iLEAPP on the full file system and on any sysdiagnose; run APOLLO over the pattern-of-life databases; export commercial suite results with paths.
  3. Normalise everything into the common schema, in UTC, with provenance.
  4. Tag device attribution and deduplicate.
  5. Filter to the time windows and people that matter; keep the full set in an annex.
  6. Validate with anchors, cross-source agreement and, where needed, a reference device.
  7. Write the narrative from the validated rows only.

Common mistakes

  • Reading sms.db nanoseconds as seconds, or Signal milliseconds as seconds.
  • Mixing Unix and Cocoa seconds and shifting events by 31 years.
  • Printing log show output in the examiner's local time.
  • Using raw PowerLog timestamps.
  • Merging synced records from other devices into this device's activity.
  • Counting the same event several times because it appears in several copies.
  • Presenting gaps as inactivity when the WAL files were never collected.

For the sources themselves, start with the pattern of life guide, the location guide and the messaging guide.

Related guides

05 · Location & Movement

iOS Location Forensics: Where Was the iPhone?

Every iPhone location source compared: Significant Locations, photo GPS, Wi-Fi networks, locationd caches, Biome and app data, with precision and retention.

Read guide