Timestamp Sequence Generator

What this generator does

Produces an ordered sequence, which is the thing the existing random timestamp generator deliberately does not do. That tool scatters independent timestamps through a range, so they arrive unsorted, can collide and can leave large gaps. This one guarantees each entry is later than the one before, at a controlled distance — which is what you need to test anything that reads data in time order.

How to use this tool

1. Pick a start date and time, read as UTC.
2. Set how many timestamps you need and the gap between them.
3. Add jitter if perfectly regular spacing would be unrealistic.
4. Choose a format and copy the list.

Understanding the controls

Start

The first timestamp, read as UTC regardless of where you are. That is deliberate: a fixture that changes meaning depending on the machine that generated it is worse than useless in a shared repository.

How many

The number of timestamps, up to 500. Together with the interval this fixes the total span, shown above the results in plain language.

Interval and unit

The nominal gap between consecutive entries. Changing the unit rescales the whole sequence, so the same count can cover five minutes or five months.

Jitter

Varies each gap by up to that percentage either way. Zero produces perfectly even spacing, which can hide bugs in anything that buckets by time; the cap of 90% means an entry can never overtake the next one.

Format

ISO 8601 for JSON and APIs, epoch seconds or milliseconds for anything numeric, SQL datetime for direct insertion, or date and time only where a fixture needs just one part.

Seed

With jitter switched on the sequence is random, so a seed is what makes a committed fixture reproducible. With jitter at zero the output is already deterministic and the seed changes nothing.

Worked examples

20 entries, 5 minutes apart, no jitter

A perfectly even run spanning 1 hour 35 minutes from the start time.

100 entries, 30 seconds apart, 40% jitter

Gaps varying between 18 and 42 seconds, still strictly increasing, spanning roughly 50 minutes.

365 entries, 1 day apart, date-only

A year of dates, one per row, ready to join against daily aggregates.

Common use cases

• Seeding a table with rows that span a realistic period
• Testing a chart, a rolling average or a time-bucketed query
• Checking that pagination by timestamp behaves at boundaries
• Producing fixture data that a colleague can regenerate identically from a seed
• Filling a demo dashboard with data that looks plausible

How this generator works

The first entry is placed exactly at your start instant. Each subsequent entry adds the nominal gap plus a random offset drawn uniformly from plus or minus the jitter percentage of that gap. Because the jitter is capped strictly below the gap itself, the offset can never cancel or exceed it, so the sequence is guaranteed to increase strictly — every entry is later than the one before, with no ties. All arithmetic is done in epoch milliseconds and formatted from UTC, so the output does not depend on the machine's time zone.

Randomness and fairness

With jitter at zero nothing is random at all and two runs produce identical output. Randomness only enters through the jitter offset, and even then it is bounded, so the ordering guarantee never depends on luck. The seeded mode uses a small generator that is deterministic, not cryptographic — appropriate for fixture data, and never suitable for anything security-sensitive.

For how randomness is produced across the whole site, see how Generate Random works.

Limitations and good to know

• Everything is UTC. There is no time-zone or daylight-saving handling, so if you need a sequence that crosses a clock change you will have to apply that offset yourself.
• The interval is uniform apart from jitter. Real traffic has daily and weekly cycles, and nothing here will produce a quiet period overnight or a spike at lunchtime.
• Jitter is drawn from a flat distribution, so gaps are evenly spread across the band rather than clustering around the nominal value the way real arrival times do.
• Five hundred entries is the ceiling. For larger fixtures, generate the pattern here and extend it programmatically.

Common mistakes

Expecting the start time to be in local time

The picker is read as UTC. If you need a local-time fixture, offset your start value by hand before entering it.

Using zero jitter and then wondering why a time-bucketing bug went unnoticed

Perfectly regular timestamps land neatly inside buckets and hide off-by-one errors at boundaries. Add 30 to 50% jitter for anything that groups by period.

Regenerating a jittered sequence that a test asserts against

Set a seed before generating and record it alongside the fixture, or the next regeneration will produce different values and break the test.

Practical tips

• Generate with the epoch-milliseconds format when the destination is code and ISO when it is a JSON fixture — it saves a conversion step either way.
• For a fixture that spans an interesting boundary, set the start just before midnight or just before the hour and let the sequence cross it.

Privacy and your data

Nothing you enter here is personal, and nothing is transmitted regardless: the start time, interval and format are read and the sequence computed entirely inside your browser. No values are stored between visits, none reach the page address, and analytics records only how many entries were produced.

Frequently asked questions

How is this different from the random timestamp generator?

That one produces independent timestamps scattered through a range, unsorted and possibly colliding. This one produces an ordered sequence with controlled gaps.

Are the timestamps guaranteed to be in order?

Yes. Jitter is capped below the interval, so no entry can ever overtake the next.

Which time zone is used?

UTC throughout, so the same inputs produce the same output on any machine.