Skip to content
Facteur

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.

datadog · step 2 Synthetics
// 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
The key only reads. The search answers at once, and the step plays it again every second, 45 seconds at most here.
monitor-signup.ts TypeScript
// 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);
Your monitor measures the delay itself: it is your figure, in your tool.

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.

  1. 01

    The monitor creates an account on your production environment, with a unique address in your monitoring inbox.

  2. 02

    It waits for the verification code: it sends the search again every second until the code arrives, and your monitor measures the delay.

  3. 03

    It reads the code, already isolated from the body, and completes the signup.

  4. 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

01

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.

02

Read-only keys

ws:read

A 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.

03

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.

04

The code, already extracted

message.otp

The monitor reads the otp field instead of looking for the code in the body with a regular expression.

05

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.

06

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.

01
Not yet

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.

02
Not yet

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.

03
Not yet

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.

04
Not yet

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.

01

Datadog Synthetics

A multistep API test: trigger the journey, wait for the message, extract the code, carry on.

02

Grafana Synthetic Monitoring

Same principle, through scripted k6 checks.

03

Checkly

Playwright scenarios run continuously, with an HTTP call to the message search.

04

StatusCake, Uptrends

For the simple checks: does the message arrive, and how fast.

05

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.