Your tests stop at CI. Your critical journeys do not.
A signup journey that breaks in production almost never breaks at deploy time: it degrades on a Thursday evening, at a router, on one domain. The only way to know is to replay it continuously, verification code included.
// Step 2 of a Datadog Synthetics multistep API test.
// Retries of the step: 45 times, every 1,000 ms. No sleep.
GET https://api.facteur.eu/messages
?inbox=p9x4k2ab
&sentTo=signup%2B{{ RUN_ID }}%40
Authorization: Bearer {{ FACTEUR_READONLY_KEY }}
// Assertions of the step (a failure runs the step again)
// status is 200
// body.messages[0].otp matches [0-9]{6}
// → extract body.messages[0].otp into the OTP variable for step 3
// A scheduler and two HTTP calls are enough.
const auth = { authorization: 'Bearer ' + process.env.FACTEUR_READONLY_KEY };
const address = 'signup+' + Date.now() + '@p9x4k2ab.inbox.facteur.eu';
const started = Date.now();
await signUp(address); // your journey, in production
const search = new URLSearchParams({ inbox: 'p9x4k2ab', sentTo: address });
let messages = [];
while (messages.length === 0 && Date.now() - started < 45_000) {
({ messages = [] } = await (await fetch('https://api.facteur.eu/messages?' + search, { headers: auth })).json());
if (messages.length === 0) await new Promise((resolve) => setTimeout(resolve, 1000));
}
if (messages.length === 0) throw new Error('no code within 45 s');
console.log('code received in', Date.now() - started, 'ms');
await confirm(address, messages[0].otp);
What a monitored journey really checks
An HTTP check on your signup page tells you it responds. It does not tell you that a user can sign up.
-
01
The monitor creates an account on your production environment, with a unique address in your monitoring inbox.
-
02
It waits for the verification code: it sends the search again every second until the code arrives, and your monitor measures the delay.
-
03
It reads the code, already isolated from the body, and completes the signup.
-
04
It deletes the test account, and starts again in five minutes.
The day your email router starts taking three minutes, you know before your users do. And your monitoring tool has the figure to prove it to your provider.
Monitoring is not testing
This address never changes
A monitoring inbox lives for months: its address is declared in your monitor, sometimes in an allow list on the sender side. A Facteur inbox does not expire: it keeps its address until you delete it.
Read-only keys
ws:readA monitor must not be able to create or delete anything. An API key only reads by default, can be limited to some workspaces, and expires after the time you set, from one day to one year. If it leaks into a monitoring configuration, the damage stays bounded.
The message read as soon as it lands
GET /messages?since=The search answers at once, and your scenario sends it again every second. It has no sleep, and the delay measured is the one of your journey, to within a second.
The code, already extracted
message.otpThe monitor reads the otp field instead of looking for the code in the body with a regular expression.
Keep monitoring safe from CI
A monitoring inbox does not have a reserve of its own yet. Until it does, put a ceiling on your CI and load-test inboxes: a test that runs away stops at its limit, instead of draining the volume your monitors need.
The measure is yours
Your monitoring tool measures the delay of each run. You set its threshold where your on-call rota already lives, and that tool decides who gets woken.
What is not available yet
Each line describes today's state.
Capacity reserved for monitoring
An inbox marked "monitoring" would have its own reserve, and keep accepting even with the account exhausted. This reserve does not exist today: a monitoring inbox uses the same volume as the others.
Reception time as a metric
Facteur does not publish a reception metric to set thresholds on yet. Each message carries its reception time in the deliveryMs field, which your monitor can read.
Performance mode
Confirm reception, measure, and keep nothing. This mode is not offered today: a received message is kept for the duration of your plan.
A key limited to one inbox or to IP addresses
Today, a key is limited to workspaces. It cannot be limited to a single inbox, nor to IP addresses.
From the tool you already use
There is nothing to install: a read-only key and an HTTP call that waits.
Datadog Synthetics
A multistep API test: trigger the journey, wait for the message, extract the code, carry on.
Grafana Synthetic Monitoring
Same principle, through scripted k6 checks.
Checkly
Playwright scenarios run continuously, with an HTTP call to the message search.
StatusCake, Uptrends
For the simple checks: does the message arrive, and how fast.
Your own scheduler
A cron and an HTTP search sent again every second are enough.
Monitor what actually matters
A journey validated by email, replayed every five minutes from your monitoring tool, with a key that only reads.