Vérifier le SPF

Objectif

Vérifiez l’enregistrement SPF d’un domaine : quels serveurs peuvent envoyer des e-mails en son nom, ce qui arrive à tous les autres (« -all », « ~all », « +all »), combien de requêtes DNS il nécessite par rapport à la limite de 10, et chaque include.

Prérequis

Tout le monde peut lire ces guides, sans compte. Certains outils nécessitent Pro, comme indiqué dans chaque guide.

Le SPF est l’enregistrement DNS dans lequel un domaine liste les serveurs autorisés à envoyer ses e-mails. Sans lui, ou avec un SPF cassé ou trop ouvert, il est plus facile d’envoyer de faux e-mails au nom de ce domaine. Saisissez un domaine, une adresse e-mail ou un lien et nous lirons son SPF pour vous l’expliquer.

Mode d’emploi

1. 1

   Saisissez le domaine que vous voulez vérifier, ou collez une adresse e-mail ou un lien : nous n’utilisons que son domaine.

2. 2

   Appuyez sur « Vérifier le SPF ». Nous lisons l’enregistrement SPF et suivons chaque include, comme le ferait un serveur de réception.

3. 3

   Regardez comment se termine l’enregistrement et le nombre de requêtes : ce que vous voulez voir, c’est « -all » ou « ~all » et 10 requêtes ou moins.

Exemple fictif

v=spf1 include:_spf.example.com ~all

Interpréter le résultat

Ce domaine n’a pas de SPF: Il n’indique pas quels serveurs peuvent envoyer ses e-mails, ce qui facilite l’usurpation de son identité. Si c’est votre domaine, publiez un enregistrement SPF.

L’enregistrement SPF contient des erreurs: Les serveurs de réception ne peuvent pas l’appliquer : pour eux, le domaine n’a pas de SPF. Les signaux ci-dessous indiquent ce qui ne va pas.

N’importe qui peut envoyer des e-mails au nom de ce domaine: L’enregistrement se termine par « +all », qui autorise tous les serveurs du monde. Configuré ainsi, le SPF ne protège rien.

Le SPF ne protège pas complètement le domaine: L’enregistrement ne dit pas quoi faire des serveurs qui ne figurent pas sur sa liste : les faux e-mails au nom du domaine ne sont donc pas signalés.

Le SPF est bien configuré: Le domaine liste les serveurs qui peuvent envoyer ses e-mails et demande aux serveurs de réception de signaler ou de rejeter les autres. Le SPF seul n’empêche pas l’usurpation : c’est le DMARC qui indique aux serveurs de réception quoi faire.

+all : n’importe quel serveur peut envoyer (dangereux)

?all : l’enregistrement ne dit rien à leur sujet

~all : marqués comme suspects

-all : rejetés

Pas de « all » : l’enregistrement ne dit rien à leur sujet

Limites

Résoudre un problème

Cela ne ressemble pas à un domaine public. Essayez par exemple avec example.com.

Le DNS n’a pas répondu à temps. Réessayez dans quelques secondes.

Vous avez lancé beaucoup de vérifications d’affilée. Attendez une minute et réessayez.

Utiliser avec l’API

Lit l’enregistrement SPF d’un domaine comme le font les serveurs de réception (RFC 7208) : ses termes, ce par quoi il se termine, les requêtes DNS de tout l’arbre d’include par rapport à la limite de 10, chaque include et s’il publie un SPF, ainsi que les problèmes de l’enregistrement sous forme de signaux. Rien n’est enregistré.

Envoyez le corps JSON à la route propre au tool, ou à POST /v2/tools en ajoutant le champ tool. Les deux routes renvoient le même résultat.

POST https://api.nocall.io/v2/spf-check
POST https://api.nocall.io/v2/tools  {"tool":"spf-check","domain":"example.com"}

REQUEST_ID="$(uuidgen)" && [ -n "$REQUEST_ID" ] &&
curl --request POST 'https://api.nocall.io/v2/spf-check' \
  --header "Authorization: Bearer $NOCALL_API_KEY" \
  --header 'Content-Type: application/json' \
  --header "Idempotency-Key: $REQUEST_ID" \
  --data '{"domain":"example.com"}'

import json
import os
import urllib.request
import uuid

api_key = os.environ.get('NOCALL_API_KEY')
if not api_key:
    raise SystemExit('Set NOCALL_API_KEY')

request = urllib.request.Request(
    'https://api.nocall.io/v2/spf-check',
    method='POST',
    data=json.dumps({'domain': 'example.com'}).encode(),
    headers={
        'Authorization': 'Bearer ' + api_key,
        'Content-Type': 'application/json',
        'Idempotency-Key': str(uuid.uuid4()),
    },
)
with urllib.request.urlopen(request, timeout=30) as response:
    result = json.load(response)
print(result['data']['result'], result['meta']['unitsCharged'])

import { randomUUID } from 'node:crypto';

const requestId = randomUUID();
const apiKey = process.env.NOCALL_API_KEY;
if (!apiKey) throw new Error('Set NOCALL_API_KEY');

const response = await fetch('https://api.nocall.io/v2/spf-check', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer ' + apiKey,
    'Content-Type': 'application/json',
    'Idempotency-Key': requestId,
  },
  body: JSON.stringify({ domain: 'example.com' }),
});
const result = await response.json();
if (!response.ok) throw new Error(result.error?.code ?? 'request_failed');
console.log(result.data.result, result.meta.unitsCharged);

{
  "data": {
    "tool": "spf-check",
    "result": {
      "domain": "example.com",
      "domainAscii": "example.com",
      "found": true,
      "record": "v=spf1 include:_spf.google.com ~all",
      "recordCount": 1,
      "terms": [
        {
          "qualifier": "pass",
          "mechanism": "include",
          "value": "_spf.google.com"
        },
        {
          "qualifier": "softfail",
          "mechanism": "all",
          "value": null
        }
      ],
      "allResult": "softfail",
      "lookups": 1,
      "includes": [
        {
          "domain": "_spf.google.com",
          "found": true
        }
      ],
      "signals": [
        "softfail_all"
      ],
      "valid": true,
      "attention": false
    }
  },
  "meta": {
    "requestId": "req_example",
    "unitsCharged": 1,
    "usage": {
      "periodStart": "2026-10-01",
      "unitLimit": 20,
      "unitsUsed": 3,
      "unitsRemaining": 17
    }
  }
}

• Référence API ↗

Questions fréquentes

Guides associés

• Vérifier le DMARC
• Vérifier le DKIM
• Enregistrements MX d’un domaine