Adjust S2S Event Older Than 58 Days: 4 Causes and a Quick Fix

Short answer: Adjust rejects a server-to-server event when its timestamp is more than 58 days old. It also rejects an event whose timestamp is earlier than one Adjust already received for the same device and event token. Both rules apply to the created_at_unix parameter. Send events inside the 58 day window, sort queued events by timestamp before you replay them, and never backfill an older event after a newer one for the same device and event token.

This guide is for developers, marketers and agencies who send events to Adjust from a server, a queue or a backfill script. Below you will find what the two rules mean, a BAD and a GOOD replay plan, four common causes of an Adjust S2S event older than 58 days with a way to check each one, a quick fix, a checklist and a short FAQ.

Check this example in the Attribution Debugger

The button opens the Attribution Debugger with a sample Adjust S2S event older than 58 days, where created_at_unix is more than 58 days old. The check runs in your browser and nothing is uploaded. For the ordering case, open the out of order example.

What an Adjust S2S event older than 58 days means

Adjust’s S2S events endpoint is https://s2s.adjust.com/event. A request carries the app token, the event token, one device identifier such as gps_adid, idfa or adid, and s2s=1. It can also carry a timestamp. Adjust documents created_at_unix, a UNIX timestamp, as the recommended form, with created_at, an ISO 8601 timestamp, as the alternative.

Two timestamp rules sit on Adjust’s page. All events must be submitted within 58 days, and an event with a timestamp older than 58 days is rejected. Events must also be submitted chronologically for each device and event token. If Adjust receives an event with an earlier timestamp than one it already received, it rejects the event. If you send no timestamp, Adjust uses the time it receives the event as the event date.

Adjust’s page does not list an error message or a response code for these rejections. So a request can look fine on your side while the event never counts. Confirm that events appear in Adjust, not only that your server got a response.

Two rules behind an Adjust S2S event older than 58 days

The age rule. The timestamp must not be older than 58 days. That is 5,011,200 seconds. Adjust’s page does not say in so many words how the age is measured. It describes created_at_unix as the time the event was sent, and the parameter table describes it as the time the event occurred. The practical reading, which is not an Adjust statement, is the gap between the timestamp and the moment you send the request. So an old queue cannot be replayed once its events pass that gap.

The order rule. For the same device and event token, a later request must not carry an earlier timestamp than one Adjust already received. This is the reason a recent event can be rejected too.

BAD vs GOOD replay plan

Here is a replay plan that sends three events for one device newest first. In this order, the first event is not blocked by the order rule, and the second and third are earlier than one Adjust already received, so Adjust rejects them:

Device:      00000000-0000-4000-8000-000000000001   (fake)
Event token: FAKE_EVENT_TOKEN                        (fake)

BAD: newest first
send 1   created_at_unix=1700172800
send 2   created_at_unix=1700086400   # earlier than send 1, rejected
send 3   created_at_unix=1700000000   # earlier than send 1, rejected

And the same three events sorted oldest first, which is the order Adjust expects:

GOOD: oldest first
send 1   created_at_unix=1700000000
send 2   created_at_unix=1700086400
send 3   created_at_unix=1700172800

Each send above would be one request in the form below. The values are fake. Never paste a real app token, event token or device ID into a post, a chat or a screenshot, and leave your S2S security token out of anything you share.

https://s2s.adjust.com/event?s2s=1&app_token=FAKE_APP_TOKEN&event_token=FAKE_EVENT_TOKEN&gps_adid=00000000-0000-4000-8000-000000000001&created_at_unix=1700000000
Adjust S2S event older than 58 days

4 causes of an Adjust S2S event older than 58 days and how to fix them

The two rules above come from Adjust’s S2S events page. The four causes below are common causes seen in real setups, not Adjust statements. Each one ends with a check you can run.

1. A retry queue or dead-letter queue replayed weeks later

Support: common cause, not an Adjust statement. A failed event waits in a retry queue or a dead-letter queue, and someone replays it after the 58 day window has passed.

Fix: expire or review queued events by age before replaying, and send only those inside the window.

How to check: read the oldest created_at_unix in the queue and compare it with today. If the gap is above 5,011,200 seconds, Adjust rejects it.

2. A backfill script that sends events newest first

Support: common cause, not an Adjust statement. Many databases return the latest rows first by default, so a script that loops over them sends the newest event first. Every older event for the same device and event token that follows is then earlier than one Adjust already received.

Fix: sort by timestamp, oldest first, before the first request.

How to check: log the created_at_unix of each request in the order it was sent. If the numbers go down at any point for the same device and event token, the plan is out of order.

3. A batch job that processes events in parallel and loses order

Support: common cause, not an Adjust statement. Workers that send in parallel can finish in a different order than they started, so a newer event reaches Adjust before an older one.

Fix: send events for the same device and event token one after another, in timestamp order. Parallel workers are fine for different devices.

How to check: group your log by device and event token, and check that the timestamps rise inside each group.

4. A server clock, a unit or a wrong date field

Support: common cause, not an Adjust statement. created_at_unix is a UNIX timestamp. A server clock that is wrong, a value in the wrong unit, or a field filled from the wrong date, such as the customer signup date instead of the event time, gives a timestamp that does not match the event. Adjust’s page does not describe what happens with these values, so treat the result as unpredictable.

Fix: fill created_at_unix from the real event time, in UNIX seconds.

How to check: convert one timestamp from your log to a date, and compare it with the time the action really happened.

Quick fix for an Adjust S2S event older than 58 days

Use this order to clear an Adjust S2S event older than 58 days, and the ordering rejection that often comes with it:

  1. Find the oldest timestamp in the batch you are about to send.
  2. Drop or set aside every event that is more than 58 days old at the moment of sending. Adjust rejects them.
  3. Sort the rest by created_at_unix, oldest first.
  4. Send events for the same device and event token one after another.
  5. Never send an older event after a newer one for the same device and event token.

Leaving the timestamp out does not rescue an old event. Adjust would use the time it receives the event as the event date, so the event would be recorded at the time of sending, not when it happened.

Checklist after fixing an Adjust S2S event older than 58 days

  • No event in the batch is more than 58 days old at the time of sending.
  • Events are sorted by created_at_unix, oldest first.
  • For each device and event token, timestamps only go up.
  • Workers do not send events for the same device and event token in parallel.
  • created_at_unix is the real event time in UNIX seconds.
  • Test events appear in Adjust, not only in your server log.

Check your own Adjust S2S event older than 58 days

Paste the request or the error text for your Adjust S2S event older than 58 days into the Attribution Debugger, and it explains the likely causes. It reads only what you paste. It cannot see inside your Adjust account and it cannot fix a queue, so paste the request with fake or removed tokens, never a real token. The check runs in your browser and nothing is uploaded.

Check this example in the Attribution Debugger

For the ordering case, use the out of order example. If the findings are more than you want to fix yourself, use the buttons under the report to request a written fix plan. For more guides like this one, go back to the debug hub, or read the AppsFlyer S2S 401 guide and the action_source missing guide. Source: Adjust, Server-to-server (S2S) events API.

Frequently asked questions

How old can an Adjust S2S event be?

An Adjust S2S event older than 58 days is rejected. Adjust’s S2S events page says all events must be submitted within 58 days, and that an event with a timestamp older than 58 days is rejected. The timestamp in question is created_at_unix.

Why was my event rejected even though it is recent?

The second rule is the likely one. Adjust rejects an event whose timestamp is earlier than one it already received for the same device and event token. A recent event can break it if a newer event for the same device and event token was sent first. Also check that created_at_unix holds the real event time.

Does the 58 days count from the event time or the send time?

Adjust’s page does not spell out how the age is measured. It describes created_at_unix as the time the event was sent and also as the time the event occurred. The practical reading, which is not an Adjust statement, is the gap between the timestamp and the moment you send the request. 58 days is 5,011,200 seconds.

Can I resend events older than 58 days?

Not with their original timestamp. Adjust rejects an event whose timestamp is older than 58 days. Adjust also says that if you send no timestamp, it uses the time it receives the event as the event date, so the event would be recorded at the time of sending, not when it happened. Treat that as a reporting decision, not a fix.

Does event order matter?

Yes. Adjust’s page says events must be submitted chronologically for each device and event token, and that it rejects an event with an earlier timestamp than one it already received. Send queued events oldest first.

Can I test this without sending real data?

Yes, in two ways that do not need real data. Paste a sample request into the Attribution Debugger, which checks it in your browser and uploads nothing. Or plan the replay on paper with fake tokens and fake device IDs, and check the order and the age of each timestamp before you send anything real.

Built by Al-Fahad Hridoy, an Attribution & Tracking Consultant who fixes Meta Conversions API, WhatsApp click-to-chat, AppsFlyer and Firebase tracking for apps and websites.