Récupérer le Mobilithek allemand en mTLS — guide pratique

Mobilithek est le point d'accès national allemand — le hub fédéral pour les données de trafic, de mobilité et de recharge AFIR, exploité par T-Systems pour le compte du BMDV. Depuis le retrait opérationnel du MDM (Mobility Data Marketplace) au 1^er semestre 2025, Mobilithek est le point d'entrée canonique pour toute intégration de mobilité allemande en production. À partir du 14 avril 2026, DATEX II y devient le format d'échange obligatoire.

La plupart des API publiques utilisent une clé API. Pas Mobilithek. Elle utilise une authentification par certificat client TLS (mTLS) : votre client présente un certificat X.509 pendant la poignée de main TLS, et le broker décide si vous pouvez tirer ou recevoir des push.

Cela bloque presque toutes les premières intégrations. Pas d'en-tête Authorization: Bearer .... Pas de clé API. Si la poignée de main TLS échoue, vous obtenez une erreur de connexion générique et un long après-midi de débogage. Voici le guide pratique que nous aurions aimé avoir.

1. Obtenir un compte consommateur Mobilithek

Faites votre demande sur mobilithek.info/registration-request. Vous remplissez :

Détails de l'organisation et votre rôle
Description du cas d'usage (quels jeux de données, pourquoi, volume de requêtes attendu)
Si vous voulez un compte consommateur de données, fournisseur de données, ou les deux

Pour une intégration NAP typique, vous voulez « consommateur de données ». Les consommateurs de données publiques ne paient pas ; les consommateurs de données commerciales peuvent payer selon le publieur. Le provisionnement prend quelques jours.

2. Générer votre certificat

Une fois validé, le composant d'administration vous laisse téléverser une demande de signature de certificat (CSR) et télécharger le certificat émis. Générez le couple de clés localement :

# 1. Générer une clé privée RSA 4096 bits
openssl genrsa -out mobilithek.key 4096

# 2. Construire la CSR. Le CN doit correspondre au nom d'organisation enregistré.
openssl req -new -key mobilithek.key -out mobilithek.csr \
  -subj "/CN=YourOrgName/O=YourOrg/C=DE"

# 3. Téléverser mobilithek.csr dans le composant d'administration Mobilithek.
# 4. Télécharger le certificat émis sous mobilithek.crt

Vous aurez aussi besoin du CA racine Mobilithek et de toute CA intermédiaire pour vérifier le côté serveur de la poignée de main.

3. Disposition des fichiers

Sur le serveur applicatif, organisez les fichiers ainsi :

/etc/napspan/mobilithek/
├── client.crt   # le certificat émis pour vous
├── client.key   # la clé privée (chmod 600)
└── ca.pem       # bundle CA Mobilithek pour la vérification serveur

Les permissions comptent : la clé privée doit être en chmod 600 et appartenir à l'utilisateur sous lequel tourne le worker. Pas de clés chiffrées en production — le worker demanderait une passphrase à chaque démarrage. Si vous avez besoin de chiffrement au repos, chiffrez le volume, pas le fichier.

Référencez ces chemins via des variables d'environnement pour que le binaire reste sans secret :

MOBILITHEK_CERT_PATH=/etc/napspan/mobilithek/client.crt
MOBILITHEK_KEY_PATH=/etc/napspan/mobilithek/client.key
MOBILITHEK_CA_PATH=/etc/napspan/mobilithek/ca.pem

4. Le motif d'URL du broker

Chaque jeu de données Mobilithek a un Publikations-ID numérique. Le motif d'URL du broker est :

https://mobilithek.info:8443/mobilithek/api/v1.0/publication/<Publikations-ID>

Notez le port non standard 8443. C'est l'endpoint protégé par mTLS — le 443 standard sert uniquement le site public. En mode pull, vous récupérez l'URL du broker à intervalles réguliers. En mode push, vous enregistrez votre propre endpoint dans le composant d'administration et le broker vous envoie des POST à chaque mise à jour de la publication — vous répondez par une confirmation. Les deux modes partagent la même racine d'API v1.0.

5. Un client Go fonctionnel

Voici le client Go minimal que nous utilisons pour récupérer une publication Mobilithek. Il construit une tls.Config avec le certificat client et le pool CA, l'attache à un http.Transport, et réutilise un seul client pour toutes les requêtes Mobilithek.

package mobilithek

import (
    "crypto/tls"
    "crypto/x509"
    "fmt"
    "io"
    "net/http"
    "os"
    "time"
)

func NewClient(certPath, keyPath, caPath string) (*http.Client, error) {
    cert, err := tls.LoadX509KeyPair(certPath, keyPath)
    if err != nil {
        return nil, fmt.Errorf("load client cert: %w", err)
    }
    caPEM, err := os.ReadFile(caPath)
    if err != nil {
        return nil, fmt.Errorf("read ca: %w", err)
    }
    pool := x509.NewCertPool()
    if !pool.AppendCertsFromPEM(caPEM) {
        return nil, fmt.Errorf("parse ca pem")
    }
    transport := &http.Transport{
        TLSClientConfig: &tls.Config{
            Certificates: []tls.Certificate{cert},
            RootCAs:      pool,
            MinVersion:   tls.VersionTLS12,
        },
        MaxIdleConns:        20,
        IdleConnTimeout:     90 * time.Second,
        TLSHandshakeTimeout: 10 * time.Second,
    }
    return &http.Client{
        Transport: transport,
        Timeout:   60 * time.Second,
    }, nil
}

func FetchPublication(c *http.Client, pubID string) ([]byte, error) {
    url := fmt.Sprintf(
        "https://mobilithek.info:8443/mobilithek/api/v1.0/publication/%s",
        pubID,
    )
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        return nil, err
    }
    req.Header.Set("Accept", "application/xml")
    req.Header.Set("User-Agent", "NAPSPAN/1.0")

    resp, err := c.Do(req)
    if err != nil {
        return nil, fmt.Errorf("mobilithek request: %w", err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
    if resp.StatusCode != 200 {
        return nil, fmt.Errorf("mobilithek %d: %s", resp.StatusCode, string(body))
    }
    return body, nil
}

Le résultat est un document DATEX II XML — généralement une SituationPublication ou une VmsTablePublication, selon la Publikations-ID récupérée. Passez-le à votre parser DATEX II et l'authentification est réglée.

6. Modes d'échec courants

« Connection reset » ou « EOF » juste après ClientHello

Presque toujours un problème de certificat. Le broker rejette la poignée de main sans alerte TLS. Triage :

Vérifier que le certificat est bien celui provisionné pour cet environnement (Mobilithek émet des certificats distincts pour la pré-prod et la prod).
Vérifier que le certificat n'a pas expiré. Les renouvellements sont manuels ; personne ne vous écrira le jour J de l'expiration.
Lancer openssl s_client -connect mobilithek.info:8443 -cert client.crt -key client.key -CAfile ca.pem et lire la sortie de la poignée de main.

HTTP 403 après une poignée de main réussie

La couche TLS vous a accepté, mais le broker n'autorise pas ce certificat pour la Publikations-ID demandée. Soit vous n'avez pas souscrit à cette publication dans le composant d'administration, soit votre abonnement a été révoqué. Vérifiez dans le tableau de bord consommateur.

HTTP 410 Gone

La publication a été retirée. Parfois, les jeux de données migrent vers une nouvelle Publikations-ID — surtout pendant la phase de transition MDM-vers-Mobilithek de 2025. Consultez le catalogue de publications.

Données obsolètes malgré un 200

Mobilithek met certaines publications en cache derrière un CDN. Vérifiez l'en-tête Last-Modified et sautez le parsing s'il n'a pas bougé. Sans en faire la vérité absolue : certains publieurs ne le mettent pas à jour correctement.

7. Limites de débit et politesse

Mobilithek ne publie pas de limites de débit dures, mais en pratique :

La plupart des publications temps réel se rafraîchissent toutes les 30 sec à 5 min — poller plus vite que le publieur ne se rafraîchit est du gaspillage
Une connexion persistante par worker suffit — le http.Transport de Go la garde vivante entre requêtes
Définissez un User-Agent parlant — si le broker doit limiter un consommateur défaillant, vous voulez être joignable
Si vous avez besoin d'une latence très basse, enregistrez un abonnement push plutôt que de poller

8. Ce que vous récupérez

Une publication d'incidents typique ressemble à ceci :

<d2:payloadPublication
    xsi:type="d2:SituationPublication"
    lang="de"
    xmlns:d2="http://datex2.eu/schema/2/2_0">
  <d2:publicationTime>2026-05-01T08:34:00Z</d2:publicationTime>
  <d2:publicationCreator>
    <d2:country>de</d2:country>
    <d2:nationalIdentifier>DE-Mobilithek</d2:nationalIdentifier>
  </d2:publicationCreator>
  <d2:situation id="DE_BAB7_4711">
    <d2:situationRecord
        xsi:type="d2:Accident"
        id="DE_BAB7_4711_R1"
        version="3">
      <d2:situationRecordVersionTime>2026-05-01T08:30:00Z</d2:situationRecordVersionTime>
      ...
    </d2:situationRecord>
  </d2:situation>
</d2:payloadPublication>

Parsez les SituationRecords, mappez les champs sur votre TrafficEvent normalisé, persistez et faites un diff avec le pull précédent pour suivre le cycle de vie — nouvelle gravité, nouvelle heure de fin estimée, archivage.

9. Comment cela s'intègre dans NAPSPAN

Mobilithek est l'un des 30+ NAPs que NAPSPAN agrège. La poignée de main mTLS décrite ici est encapsulée dans un seul mobilithekClient réutilisé par tous les adaptateurs — events, recharge AFIR, parking, météo. Ajouter une nouvelle publication Mobilithek est une seule ligne :

Register("mobilithek", "afir_charging", fetchMobilithekAFIR)

La fonction de fetch utilise le client partagé, appelle FetchPublication avec la bonne Publikations-ID, donne le XML au parser DATEX II et renvoie des features normalisés. Même signature FetchFunc que les autres NAPs — le scheduler ignore que celui-ci a besoin d'un certificat client TLS.

L'essayer sans gérer les certificats

Si vous voulez les données des autoroutes allemandes sans monter votre propre compte Mobilithek, c'est exactement ce que résout NAPSPAN — nous gérons les certificats, les parsers et le suivi de cycle de vie, et nous livrons le résultat via une clé API normale en HTTPS classique :

curl "https://api.napspan.com/api/v1/events?country=DE&status=active" \
  -H "X-API-Key: your_key"

Carte en direct — explorer les données visuellement
Documentation API — référence complète des endpoints
Portail développeur — s'inscrire et obtenir une clé API

Le flux mTLS de Mobilithek est bien conçu une fois les pièces en place — c'est l'absence d'un guide de bout en bout fonctionnel qui rend la première intégration douloureuse. Si cet article vous a évité un après-midi de débogage, ça nous fera plaisir de le savoir.

Prêt à essayer NAPSPAN ?

Essai gratuit de 14 jours. Aucun certificat à gérer. UE 27 + UK + AELE, normalisé.

Obtenir une clé API gratuite Explorer la carte