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
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":{…}}'
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
Une clé est créée avec le plan Diagnostic (10 scels/mois). Elle n'est affichée qu'une seule fois.
Plan · scels/mois. Pour augmenter le quota, voir l'abonnement.
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.
.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.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 } }
data (requis, str ou objet JSON) · mode (local par défaut, eidas pour l'horodatage RFC 3161) · tsa (pour eidas : freetsa | certigna | universign).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.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).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 }
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 }
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éthode | Endpoint | Rôle | Auth |
|---|---|---|---|
| GET | /account | Vue complète (plan, quota, crédits, abo, liste des clés) | clé ou fichier-clé |
| GET | /account/seals | Historique des scels (50 derniers) | clé ou fichier-clé |
| POST | /account/keys | Ajouter une clé API au compte | fichier-clé |
| POST | /account/keys/revoke | Révoquer une clé (pas la clé maître) | fichier-clé |
| POST | /account/keyfile/rotate | Rotation 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"
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}).
| Endpoint | Verticale | Champs requis |
|---|---|---|
POST /c2pa | Origine de contenu (C2PA / Content Credentials — humain vs IA) | manifest |
POST /consent | Consentement RGPD art.7 | purpose, consent |
POST /agent | Preuve d'exécution d'un agent IA (AI Act art.12) | agent_id, action |
POST /incident | Timeline d'incident NIS2 (détection → remédiation) | incident_id, phase |
POST /contrefacon | Contrefaç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"}'
| Méthode | Endpoint | Rôle |
|---|---|---|
| GET | /chain | État de la chaîne d'audit immuable + ancrage Hedera HCS |
| GET | /pubkey | Clé 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
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éthode | Endpoint | Rôle |
|---|---|---|
| POST | /webhooks | Abonner un webhook (url + events) |
| GET | /webhooks | Lister + dernier statut de livraison |
| POST | /webhooks/delete | Supprimer 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": "…" } }
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.Trois plans + des packs de scels à l'unité. Le quota se réinitialise chaque mois. Les crédits (packs) ne périment pas.
Abonnement via Stripe Checkout : POST /checkout avec {"product":"standard","email":"…","account_id":…}. Géré automatiquement par webhook (activation / résiliation).
| Méthode | Endpoint | Rôle |
|---|---|---|
| POST | /seal | Sceller une donnée (quota) |
| POST | /verify | Vérifier une preuve (gratuit) |
| POST | /keys | Inscription : clé API + fichier-clé |
| POST | /auth/keyfile | Login fichier-clé (keyfile_id + hash) |
| GET | /usage | État de la clé |
| GET | /account | Vue complète du compte |
| GET | /account/seals | Historique des scels |
| POST | /account/keys | Ajouter une clé API |
| POST | /account/keys/revoke | Révoquer une clé API |
| POST | /account/keyfile/rotate | Rotation de la clé maître |
| POST | /webhooks | Abonner un webhook sortant |
| GET | /webhooks | Lister les webhooks |
| POST | /webhooks/delete | Supprimer un webhook |
| POST | /checkout | Session Stripe (abo / pack) |
| POST | /checkout/verticale | Checkout verticale (prospect froid) |
| GET | /delivery | Remise config après paiement (show-once) |
| POST | /contrefacon | Contrefaçon inversée |
| POST | /c2pa | Origine de contenu (C2PA) |
| POST | /consent | Consentement RGPD |
| POST | /agent | Preuve d'agent IA (AI Act) |
| POST | /incident | Timeline d'incident NIS2 |
| GET | /proof/{digest} | Preuve stockée par digest |
| GET | /chain | Chaîne d'audit + ancrage |
| GET | /pubkey | Clé publique Ed25519 |
| GET | /modes | Modes de scellement |
| GET | /plans | Plans & packs |
| GET | /health | État du service |
Deux SDK officiels, zéro dépendance. Téléchargez-les ou copiez-collez.
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
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
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
openapi-generator-cli generate -i https://scel.0data.fr/openapi.json -g python -o client/ produit un client Python complet en une commande.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.
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.
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).
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.
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.
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.
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.