Preuve-as-a-Service · SPINA API v3

Scellez vos données
en une requête.

SHA-256 · signature Ed25519 · horodatage RFC 3161 · ancrage Hedera HCS. Une API HTTP simple, une clé, un quota mensuel. Sans installation, sans configuration, sans friction.

POST /seal  POST /verify  GET /usage  SDK Python & Node  OpenAPI

0 · Démarrage en 60 secondes #quickstart

Créez une clé, scellez, vérifiez. Trois commandes.

# 1. Créez une clé API (affichée une seule fois)
curl -X POST https://scel.0data.fr/api/keys \
  -H "Content-Type: application/json" \
  -d '{"email":"vous@exemple.fr"}'

# 2. Scellez une donnée (KEY = votre clé scel_live_…)
curl -X POST https://scel.0data.fr/api/seal \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KEY" \
  -d '{"mode":"local","data":"contrat-signé-v1"}'

# 3. Vérifiez (gratuit)
curl -X POST https://scel.0data.fr/api/verify \
  -H "Content-Type: application/json" \
  -d '{"data":"contrat-signé-v1","proof":{…}}'
Vous préférez un SDK ? Python et Node.js (zéro dépendance), ou générez votre client depuis la spécification OpenAPI.

1 · Authentification #auth

Chaque requête de scellement s'authentifie via une clé API envoyée en en-tête. Sans clé, le scellement fonctionne en mode invité (free tier limité).

# deux façons équivalentes d'envoyer la clé :
Authorization: Bearer scel_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
X-API-Key: scel_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Créer une clé API

Une clé est créée avec le plan Diagnostic (10 scels/mois). Elle n'est affichée qu'une seule fois.

Votre clé API (à conserver)

Plan · scels/mois. Pour augmenter le quota, voir l'abonnement.

Fichier-clé (login sans saisie)

Téléchargez-le et gardez-le comme une puce. Déposez-le sur scel.0data.fr pour vous connecter sans rien taper. Ne le modifiez pas, ne le partagez pas.

Fichier-clé (login sans saisie) : à la création, un fichier .key est généré (identifiant public + sel privé de signature). Son hash SHA-256 sert au login (déposez-le sur scel.0data.fr ou envoyez-le via POST /auth/keyfile — vérifié par KDF lent scrypt avec un sel propre à votre compte). La clé de signature Ed25519 est dérivée séparément (PBKDF2 du hash + du sel privé contenu dans le fichier, jamais transmis). Le fichier ne quitte jamais votre machine. Perdu = perdu, comme une puce physique.

2 · Sceller #scel

POST /seal — scelle une donnée (texte ou objet JSON). Le serveur calcule digest = SHA-256(data), signe avec une clé Ed25519 (mode local) ou un horodatage RFC 3161 (mode eidas), puis ancre sur Hedera HCS.

# requête
curl -X POST https://scel.0data.fr/api/seal \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KEY" \
  -d '{"mode":"local","data":"contrat-signé-v1"}'

# réponse (mode local — signature Ed25519, auto-vérifiable)
{
  "ok": true,
  "proof": {
    "spina": "2.0",
    "mode": "local",
    "alg": "Ed25519",
    "digest": "8f14e45f…",
    "timestamp": "2026-10-05T14:36:00.123456+00:00",
    "signature": "<128 hex>",
    "public_key": "<64 hex>",
    "authority": "SPINA Constat — 0DATA",
    "sovereign": true,
    "self_verifiable": true
  },
  "anchor": { "network": "hedera-testnet", "topic": "0.0.10605616" },
  "usage": { "plan": "standard", "used": 42, "quota": 1000 }
}
Champs : data (requis, str ou objet JSON) · mode (local par défaut, eidas pour l'horodatage RFC 3161) · tsa (pour eidas : freetsa | certigna | universign).
Zéro donnée : pour sceller un fichier sans l'envoyer, calculez sha256(file) côté client et envoyez le hash hex en data. Le fichier ne quitte jamais votre machine — c'est le flux utilisé par le tool web.
Mode local (Ed25519) : signature asymétrique, auto-vérifiable par un tiers avec la clé publique (public_key) — sans secret partagé, vérifiable sans le serveur 0DATA. Le message signé est digest + "|" + timestamp. Mode horodatage RFC 3161 : horodatage RFC 3161, non qualifié par défaut (FreeTSA) ; le qualifié passe par le QTSP de votre choix (BYO).
Mode self-custody (hors ligne) : la clé Ed25519 est dérivée de votre fichier-clé (PBKDF2 du hash du fichier + un sel privé contenu dans le fichier, jamais transmis au serveur). La signature est produite 100% côté client (hors ligne) et la preuve (clé publique + signature) est vérifiable par n'importe qui, sans serveur. Perte du fichier-clé = plus de nouvelles signatures (les preuves passées restent vérifiables).

3 · Vérifier #verifier

POST /verify — vérifie qu'une donnée correspond à sa preuve. Gratuit, sans quota.

curl -X POST https://scel.0data.fr/api/verify \
  -H "Content-Type: application/json" \
  -d '{"data":"contrat-signé-v1","proof":{…}}'

# réponse
{ "ok": true, "valid": true }

4 · Usage #usage

GET /usage — l'état de consommation de la clé (plan, quota, crédits).

curl https://scel.0data.fr/api/usage -H "Authorization: Bearer $KEY"

{ "plan": "standard", "quota_monthly": 1000,
  "used_monthly": 42, "credit_balance": 0 }

5 · Compte & clés #compte

Un compte = un email. Il peut porter plusieurs clés API. La gestion des clés (ajout, révocation, rotation) exige le login fichier-clé (Bearer <keyfile_id>:<file_hash>) — pas une simple clé API.

MéthodeEndpointRôleAuth
GET/accountVue complète (plan, quota, crédits, abo, liste des clés)clé ou fichier-clé
GET/account/sealsHistorique des scels (50 derniers)clé ou fichier-clé
POST/account/keysAjouter une clé API au comptefichier-clé
POST/account/keys/revokeRévoquer une clé (pas la clé maître)fichier-clé
POST/account/keyfile/rotateRotation de la clé maître (nouveau .key)fichier-clé
# ajouter une clé (login fichier-clé)
curl -X POST https://scel.0data.fr/api/account/keys \
  -H "Authorization: Bearer $KEYFILE_ID:$KEYFILE_HASH"

6 · Verticales réglementaires #verticales

Au-delà du scellement générique, des endpoints spécialisés scellent un enregistrement structuré (horodaté, hashé, ancré Hedera, stocké — récupérable via GET /proof/{digest}).

EndpointVerticaleChamps requis
POST /c2paOrigine de contenu (C2PA / Content Credentials — humain vs IA)manifest
POST /consentConsentement RGPD art.7purpose, consent
POST /agentPreuve d'exécution d'un agent IA (AI Act art.12)agent_id, action
POST /incidentTimeline d'incident NIS2 (détection → remédiation)incident_id, phase
POST /contrefaconContrefaçon inversée (fetch sécurisé + hash + comparaison)url
# exemple : sceller une timeline d'incident NIS2
curl -X POST https://scel.0data.fr/api/incident \
  -H "Content-Type: application/json" \
  -d '{"incident_id":"INC-2026-041","phase":"detection","description":"accès non autorisé détecté","severity":"high"}'

# exemple : sceller un consentement RGPD
curl -X POST https://scel.0data.fr/api/consent \
  -H "Content-Type: application/json" \
  -d '{"purpose":"newsletter","consent":"Oui, j\u0027accepte de recevoir la newsletter","email":"vous@exemple.fr","lang":"fr"}'

7 · Chaîne d'audit & ancrage #chaine

MéthodeEndpointRôle
GET/chainÉtat de la chaîne d'audit immuable + ancrage Hedera HCS
GET/pubkeyClé publique Ed25519 du mode local (vérification sans serveur)
GET/proof/{digest}Récupérer une preuve stockée (verticales) par digest
# vérifier l'ancrage
curl https://scel.0data.fr/api/chain

8 · Webhooks sortants (oracle) #webhooks

Quand une preuve est scellée et ancrée, 0DATA envoie un POST signé vers votre URL. C'est le déclencheur qui relie votre preuve à un smart contract, un n8n, un Zapier, un backend — sans que 0DATA ne touche à l'argent. Réservé au login fichier-clé.

MéthodeEndpointRôle
POST/webhooksAbonner un webhook (url + events)
GET/webhooksLister + dernier statut de livraison
POST/webhooks/deleteSupprimer un webhook
# abonner un webhook (login fichier-clé)
curl -X POST https://scel.0data.fr/api/webhooks \
  -H "Authorization: Bearer $KEYFILE_ID:$KEYFILE_HASH" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://vous.fr/hook","events":"seal"}'

# réponse (clé publique à épingler pour vérifier les signatures)
{ "ok": true, "id": 1, "verify": { "alg": "Ed25519", "public_key": "…" } }
Vérification côté client : le webhook porte X-0DATA-Signature = signature Ed25519 de event_id + "|" + timestamp + "|" + corps (avec les en-têtes X-0DATA-Event-Id et X-0DATA-Timestamp). Vérifiez avec la clé publique (renvoyée à l'abonnement, ou GET /pubkey). Anti-rejeu : ignorez les event_id déjà vus et les timestamp de plus de 5 minutes.
Sécurité : l'URL doit être un hôte public (http/https) — toute IP privée/réservée est refusée (anti-SSRF). Le corps du webhook ne contient que le hash (+ signature + horodatage), jamais la donnée brute.

9 · Tarifs & abonnement #abonnement

Trois plans + des packs de scels à l'unité. Le quota se réinitialise chaque mois. Les crédits (packs) ne périment pas.

Diagnostic
Gratuit
10 scels / mois
  • Mode local (Ed25519) + RFC 3161 (test, non qualifié)
  • Vérification illimitée
  • Accès API complet
Standard
49 €
/ mois · 1 000 scels
  • 1 000 scels / mois
  • API complète
  • Historique & export
Pro
149 €
/ mois · 10 000 scels
  • 10 000 scels / mois
  • Multi-flux / multi-utilisateurs
  • Support prioritaire
Packs de scels
20–100 €
one-time · crédits
  • Pack 100 scels — 20 €
  • Pack 500 scels — 100 €
  • Consommés avant le quota
Scel à l'unité : 0,50 €/scel eIDAS qualifié inclus (horodatage qualifié (RFC 3161), QTSP au choix). Dégressif au-delà de 1 000 scels.

Abonnement via Stripe Checkout : POST /checkout avec {"product":"standard","email":"…","account_id":…}. Géré automatiquement par webhook (activation / résiliation).

10 · Référence des endpoints #endpoints

MéthodeEndpointRôle
POST/sealSceller une donnée (quota)
POST/verifyVérifier une preuve (gratuit)
POST/keysInscription : clé API + fichier-clé
POST/auth/keyfileLogin fichier-clé (keyfile_id + hash)
GET/usageÉtat de la clé
GET/accountVue complète du compte
GET/account/sealsHistorique des scels
POST/account/keysAjouter une clé API
POST/account/keys/revokeRévoquer une clé API
POST/account/keyfile/rotateRotation de la clé maître
POST/webhooksAbonner un webhook sortant
GET/webhooksLister les webhooks
POST/webhooks/deleteSupprimer un webhook
POST/checkoutSession Stripe (abo / pack)
POST/checkout/verticaleCheckout verticale (prospect froid)
GET/deliveryRemise config après paiement (show-once)
POST/contrefaconContrefaçon inversée
POST/c2paOrigine de contenu (C2PA)
POST/consentConsentement RGPD
POST/agentPreuve d'agent IA (AI Act)
POST/incidentTimeline d'incident NIS2
GET/proof/{digest}Preuve stockée par digest
GET/chainChaîne d'audit + ancrage
GET/pubkeyClé publique Ed25519
GET/modesModes de scellement
GET/plansPlans & packs
GET/healthÉtat du service

11 · SDK #sdk

Deux SDK officiels, zéro dépendance. Téléchargez-les ou copiez-collez.

Python odata_scel.py

# pip install rien — stdlib uniquement
from odata_scel import SpinaClient

spina = SpinaClient(api_key="scel_live_...")
proof = spina.seal("contrat-signé-v1")
print(proof["proof"]["digest"])
print(spina.verify("contrat-signé-v1", proof["proof"]))  # {'valid': True}

# sceller un fichier SANS l'envoyer
spina.seal_file("contrat.pdf")

# verticales
spina.incident("INC-041", "detection", description="accès non autorisé")
spina.consent("newsletter", "Oui, j'accepte", email="vous@exemple.fr")

Télécharger : odata_scel.py

Node.js odata-scel

// npm install odata-scel  (ou require local, zéro dépendance)
const { SpinaClient } = require('odata-scel');
const spina = new SpinaClient({ apiKey: 'scel_live_...' });

const { proof } = await spina.seal('contrat-signé-v1');
console.log(await spina.verify('contrat-signé-v1', proof));  // { valid: true }

// sceller un fichier SANS l'envoyer
await spina.sealFile('contrat.pdf');

Télécharger : odata-scel.js · package.json

12 · Spécification OpenAPI #openapi

Générez automatiquement un client dans votre langage (openapi-generator, Postman, Swagger…) depuis la spécification machine-readable complète.

# OpenAPI 3.0 — tous les endpoints, schémas exacts
https://scel.0data.fr/openapi.json
Astuce : openapi-generator-cli generate -i https://scel.0data.fr/openapi.json -g python -o client/ produit un client Python complet en une commande.

13 · Statut de la preuve #legal

Le scellement 0DATA produit un élément de preuve technique (antériorité + intégrité), non qualifié par défaut. L'option horodatage qualifié (RFC 3161) est disponible via le prestataire de confiance de votre choix. La valeur probante reste appréciée par le juge. Aucune donnée personnelle n'est transmise en clair — seule l'empreinte SHA-256 est conservée.

14 · FAQ #faq

Comment sceller un document en ligne ?

Déposez votre fichier sur scel.0data.fr. Votre navigateur calcule son empreinte SHA-256 localement — le fichier ne quitte jamais votre machine. 0DATA horodate cette empreinte (et l'ancre sur un registre public) et vous renvoie une attestation vérifiable par un tiers. En 60 secondes, sans installation.

Qu'est-ce qu'une preuve d'antériorité ?

Elle établit qu'un document existait déjà à une date donnée, via une empreinte SHA-256 horodatée et ancrée sur un registre public. Toute modification ultérieure du document change l'empreinte et est détectable.

Combien coûte le scellement d'un document ?

Gratuit jusqu'à 10 scels par mois. Au-delà : 49 €/mois pour 1 000 scels, 149 €/mois pour 10 000 scels, ou des packs (100 scels = 20 €, 500 scels = 100 €). À l'unité : 0,50 €/scel, 0,50 €/scel eIDAS inclus horodatage qualifié (RFC 3161).

Un scellement est-il une preuve légale ?

Il produit un élément de preuve technique (antériorité + intégrité), non qualifié par défaut. L'option horodatage qualifié RFC 3161 est disponible via un prestataire de confiance de votre choix. La valeur probante reste appréciée par le juge.

Puis-je sceller hors ligne ?

Oui, avec le mode self-custody : la clé Ed25519 est dérivée de votre fichier-clé (via un sel privé contenu dans le fichier, jamais transmis), la signature est produite 100% côté client, sans serveur ni connexion. La preuve (clé publique + signature) est vérifiable par n'importe qui, hors ligne.

Quelle est la différence entre les modes local et eidas ?

Local : signature Ed25519 (asymétrique), auto-vérifiable par un tiers avec la clé publique — sans dépendre des serveurs 0DATA. eidas : horodatage RFC 3161 via une autorité de certification (FreeTSA en test, ou Certigna/Universign en qualifié). Self-custody : clé dérivée de votre fichier-clé, signature 100% hors ligne.

Où sont ancrées les preuves ?

Chaque scellement rejoint une chaîne d'audit interne (tamper-evident, chaînée par hash) et est ancré sur Hedera HCS (consensus public). L'ancrage est vérifiable par un tiers via GET /chain ou le Mirror Node Hedera.