# Start at Time Delta (/sdks/nodejs/how-to/events-store/start-at-time-delta)



## Overview [#overview]

A **time-delta subscription** starts replay from a relative offset — "the last 30 seconds" — instead of a fixed timestamp or sequence number. It's the right tool when a consumer knows how long it was offline but not the exact moment it disconnected: a worker restarting after a deploy, a dashboard reconnecting after a blip, or a batch job that only cares about "recent" history. Computing an absolute cutoff yourself is bookkeeping the broker can do for you.

`EventStoreStartPosition.StartAtTimeDelta` with `startValue` passes the offset in seconds to the broker, which resolves it to `now - delta` at subscription time, replays every stored event from that point forward, then hands off to live delivery — the same replay-to-live transition as an absolute-time or sequence-based start.

**Gotchas:** the delta is evaluated once, server-side, at subscription creation — it does not "slide" as time passes. If no events fall inside the window, the subscription simply delivers only future events from that point on. And since the window is wall-clock based, clock skew between producers and the broker can shift which events land inside or outside the boundary.

## Prerequisites [#prerequisites]

* KubeMQ server running on `localhost:50000`
* Node.js SDK installed (`npm install kubemq-js`)

## Code [#code]

```typescript title="start-at-time-delta.ts"
import { KubeMQClient, EventStoreStartPosition } from 'kubemq-js';

async function main() {
  const client = await KubeMQClient.create({
    address: 'localhost:50000',
    clientId: 'js-events-store-start-at-time-delta-client',
  });

  try {
    const sub = client.subscribeToEventsStore({
      channel: 'js-events-store.start-at-time-delta',
      startFrom: EventStoreStartPosition.StartAtTimeDelta,
      startValue: 30,
      onEvent: (event) => {
        console.log(`[seq=${event.sequence}]`, new TextDecoder().decode(event.body));
      },
      onError: (err) => {
        console.error('Error:', err.message);
      },
    });

    console.log('Subscribed with StartAtTimeDelta=30s — replays events from the last 30 seconds');
    await new Promise((r) => setTimeout(r, 2000));
    sub.cancel();
  } finally {
    await client.close();
  }
}

main().catch(console.error);

```

## How It Works [#how-it-works]

* `StartAtTimeDelta` with `startValue: 30` asks the server to replay all events published within the last 30 seconds from the moment of subscription.
* If no events exist within that window, the subscription immediately switches to `StartFromNew` semantics and delivers only future events.
* The example subscribes without publishing first — if the channel has recent events they are replayed; otherwise no events arrive and the 2-second wait exits cleanly.
* Compare with `StartAtSequence` when you need a precise checkpoint, or `StartFromFirst` when you want the full channel history regardless of time.

## Related [#related]

* [Pattern overview](/learn/events-store/getting-started)
* [Node.js SDK Reference](/sdks/nodejs/reference)
* [Persistent Pub/Sub](/sdks/nodejs/tutorials/persistent-pubsub)
* [Cancel Subscription](/sdks/nodejs/how-to/events-store/cancel-subscription)