Introduction
L'API REST JuriSign vous permet d'intégrer la signature électronique conforme eIDAS (SES) directement dans votre back-office ou votre application. Vous pouvez :
- Télécharger des documents PDF
- Créer des demandes de signature avec un ou plusieurs signataires
- Valider l'identité par code OTP email ou SMS
- Suivre l'avancement en temps réel via webhooks
- Télécharger les documents signés et les preuves d'audit
REST
API JSON standard
eIDAS SES
Signature conforme
OTP Email / SMS
Vérification d'identité
URL de base : https://www.jurisign.fr/api/v1
Vos clés : Paramètres › Clés API de votre compte — une clé de test tout de suite, une clé de production après validation de votre demande (clients abonnés), sur cette même adresse
Centre d'essai (découverte sans compte) : https://test-api.jurisign.fr/api/v1 — voir ci-dessous
Format : JSON (Content-Type: application/json)
Auth : Bearer Token (Sanctum)
Authentification
L'API utilise l'authentification par Bearer Token (Laravel Sanctum). Obtenez un token avec vos identifiants :
POST /api/v1/auth/token
// Requête
curl -X POST https://www.jurisign.fr/api/v1/auth/token \
-H "Content-Type: application/json" \
-d '{
"email": "votre@email.com",
"password": "votre_mot_de_passe",
"device_name": "mon-backoffice"
}'
// Réponse
{
"token": "1|abc123def456...",
"token_type": "Bearer",
"user": {
"id": "uuid-...",
"name": "Christophe Duval",
"email": "christophe.duval@trimaran.com",
"organization": {
"id": "uuid-...",
"name": "Trimaran"
}
}
}
Important
Conservez ce token en sécurité. Utilisez-le dans l'en-tete Authorization de toutes vos requêtes :
Authorization: Bearer 1|abc123def456...
Votre compte ou le centre d'essai : deux environnements séparés
Intégrer : votre compte jurisign.fr recommandé
https://www.jurisign.fr/api/v1
- Vos clés : Paramètres › Clés API — une clé de test (préfixe sandbox_), immédiate, et une clé de production, accordée aux clients abonnés après validation de leur demande (sous 24 h ouvrées), sur la même adresse. Par l'API : POST /auth/sandbox-token et POST /auth/token, avec vos identifiants jurisign.fr.
- Avec la clé de test, rien n'est envoyé ni facturé, le code du signataire est 123456 et la demande porte le badge « Essai » ; vos documents réels ne sont jamais touchés.
- Vos modèles, créés à la souris dans l'application, servent aux deux clés. Avec la clé de production, une signature effective consomme un crédit.
- Attention : les modèles et les webhooks ne sont pas dupliqués pour les essais. Modifier ou supprimer un modèle ou un webhook avec la clé de test agit sur vos modèles et webhooks réels. Seuls les documents, les demandes, les campagnes et les formulaires créés avec la clé de test sont isolés.
Découvrir sans compte : le centre d'essai
https://test-api.jurisign.fr/api/v1
- Votre jeton : bouton « Générer un jeton pour mon code » de la console, ou POST /auth/sandbox-token avec l'e-mail et le mot de passe de votre compte d'essai (pas ceux de jurisign.fr).
- Il commence par sandbox_ : envoyez-le tel quel, préfixe compris.
- Rien n'est facturé, et rien de ce que vous y créez n'apparaît sur jurisign.fr : le centre a sa propre base. Ses clés et ses modèles n'existent pas en production.
Pour démarrer en deux minutes : un script Python ou un script Node.js (sans dépendance), prêts à lancer, enchaînent les quatre appels (jeton, dépôt du PDF, demande, envoi) et affichent le lien de signature.
Flux complet de signature
Voici le processus en 4 étapes pour envoyer un document à la signature via l'API :
Upload PDF
POST /documents
Créer demande
POST /sign-requests
Envoyer
POST /sign-requests/{id}/send
Suivi & DL
GET + webhooks
Pas encore de clé ?
Obtenez un accès bac à sable gratuit — aucune signature réelle, aucun crédit décompté.
Télécharger un document PDF
POST /api/v1/documents
Envoyez le PDF en multipart/form-data. Taille max par fichier : 3 Mo, 10 Mo avec les offres Professionnel et Entreprise.
curl -X POST https://www.jurisign.fr/api/v1/documents \
-H "Authorization: Bearer VOTRE_TOKEN" \
-F "file=@contrat.pdf" \
-F "title=Contrat de bail 2026"
// Réponse 201
{
"data": {
"id": "doc-uuid-...",
"title": "Contrat de bail 2026",
"original_filename": "contrat.pdf",
"status": "draft",
"page_count": 5,
"file_size": 245760,
"created_at": "2026-03-31T10:00:00+02:00"
}
}
Plusieurs fichiers en un seul appel
Un contrat et ses annexes ? Envoyez-les dans files[] plutôt que dans file : JuriSign les fusionne en un seul PDF, dans l'ordre d'envoi, et vous renvoie un document unique. Jusqu'à 10 fichiers par appel (PDF, images, Word).
curl -X POST https://www.jurisign.fr/api/v1/documents -H "Authorization: Bearer VOTRE_TOKEN" -F "files[]=@contrat.pdf" -F "files[]=@annexe1.pdf" -F "files[]=@annexe2.pdf" -F "title=Contrat + annexes"
// Réponse 201 — un seul document, la somme des pages
{
"data": {
"id": "doc-uuid-...",
"title": "Contrat + annexes",
"page_count": 11,
"merged_from": 3
}
}
merged_from vous confirme le nombre de fichiers effectivement fusionnés. Le champ file au singulier continue de fonctionner à l'identique : rien à changer dans une intégration existante.
Note : Conservez l'id du document, il sera nécessaire pour créer la demande de signature.
Créer une demande de signature
POST /api/v1/sign-requests
Définissez les signataires, le canal OTP (email ou SMS), les zones de signature et la durée de validité.
curl -X POST https://www.jurisign.fr/api/v1/sign-requests \
-H "Authorization: Bearer VOTRE_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"document_id": "doc-uuid-...",
"subject": "Signature du contrat de bail",
"message": "Merci de bien vouloir signer ce document.",
"signing_order_type": 0,
"expiry_hours": 168,
"signers": [
{
"prenom": "Jean",
"nom": "Dupont",
"email": "jean.dupont@email.com",
"otp_channel": "sms",
"telephone": "+33612345678"
},
{
"prenom": "Marie",
"nom": "Martin",
"email": "marie.martin@email.com",
"otp_channel": "email"
}
],
"zones": [
{
"signer_index": 0,
"page": 5,
"x": 10,
"y": 75,
"width": 35,
"height": 10
},
{
"signer_index": 1,
"page": 5,
"x": 55,
"y": 75,
"width": 35,
"height": 10
}
]
}'
Paramètres de la demande
| document_id | UUID du document (requis) |
| subject | Objet de la demande (requis) |
| message | Message pour les signataires |
| signing_order_type | 0 = simultané, 1 = séquentiel |
| expiry_hours | Durée de validité (1 à 720 h) |
| reminders | Relances automatiques par e-mail (J+1, J+3, J+5, veille de l’expiration) : false pour les désactiver. Par défaut true. |
| sender_name | Facultatif, 100 caractères au plus : le nom présenté aux signataires pour cette demande, par exemple votre propre client. Affiché « sender_name, via votre organisation » dans l’e-mail d’invitation et sur la page de signature, et consigné au dossier de preuve. Ni adresse web ni balise HTML. |
| auto_send | true : envoie les invitations dès la création, sans second appel à /send. Par défaut false. |
| requires_paraph | true : chaque signataire trace un paraphe, distinct de sa signature, apposé en bas de chaque page. Par défaut false. |
| require_selfie | true : chaque signataire prend une photo de lui, jointe au dossier de preuve. Par défaut false. |
| identity_verification | true : avant de signer, chaque signataire fait vérifier son identité (pièce d’identité contrôlée, présence réelle, visage comparé à la photo de la pièce, nom lu sur la pièce comparé à prenom/nom). Un crédit d’identité par signataire à vérifier, décompté à l’envoi de la demande et non rendu en cas d’annulation, d’expiration ou d’échec de la vérification ; création refusée en 422 si vos crédits disponibles ne couvrent pas tous les signataires à vérifier (solde : GET /account/credits). Pour dispenser un signataire (par exemple l’expéditeur qui signe lui-même), passez "identity_verification": false sur ce signataire dans signers[] : il n’est pas vérifié, aucun crédit n’est réservé pour lui, son statut est not_required et le dossier de preuve le mentionne. Si la pièce d’identité d’un signataire porte un autre nom (nom de naissance d’une personne mariée, par exemple), indiquez-le dans signers[].birth_name : la vérification acceptera l’un ou l’autre nom, et le dossier de preuve le précisera. Résultat par signataire dans signers[].identity_verification ; événements signer.identity_verified et signer.identity_failed. Accepté aussi sur POST /templates/{id}/sign-requests et POST /bulk-campaigns, et réglable sur un modèle (POST/PUT /templates) : les demandes créées depuis ce modèle et les formulaires publics qui l’utilisent l’exigent alors (un formulaire refuse les nouvelles soumissions si vos crédits sont épuisés). En bac à sable, la vérification est simulée et ne consomme rien. La vérification renforce le dossier de preuve : la signature reste une signature électronique simple (eIDAS), ni avancée ni qualifiée. |
| require_geolocation | true : consigne au dossier de preuve le lieu de signature (position déclarée par l’appareil du signataire, avec son accord, et empreinte de l’appareil ; l’adresse IP figure déjà dans la piste d’audit). Jamais refusé : inclus à partir de l’offre Professionnel ; sinon facturé 1,25 € HT par demande sur la facture du mois (ou un jeton « lieu de signature » acheté d’avance est décompté). Jamais facturé en bac à sable. |
Paramètres signataire
| prenom | Prénom (requis) |
| nom | Nom (requis) |
| Email (requis) | |
| otp_channel | "email" ou "sms" |
| telephone | Requis si otp_channel = "sms" |
Zones de signature (coordonnées)
Les coordonnées x, y, width, height sont en pourcentage de la page (0 à 100). Le point (0,0) est en haut à gauche. signer_index correspond à l'index du signataire (0, 1, 2...).
Erreur courante : aucun email/SMS recu apres la creation
La creation d'une demande de signature (etape 2) ne declenche pas l'envoi des notifications. La demande est creee en statut draft.
Vous devez appeler l'etape 3 (POST /sign-requests/{uuid}/send) pour envoyer les emails d'invitation aux signataires.
Ce fonctionnement en 2 temps permet de verifier la demande avant envoi, ou de l'annuler si necessaire.
Envoyer aux signataires
POST /api/v1/sign-requests/{uuid}/send
Déclenche l'envoi des invitations par email à chaque signataire. Le signataire reçoit un lien sécurisé unique pour signer.
curl -X POST https://www.jurisign.fr/api/v1/sign-requests/sr-uuid-.../send \
-H "Authorization: Bearer VOTRE_TOKEN"
// Réponse 200
{
"message": "Demande envoyée aux signataires.",
"data": {
"id": "sr-uuid-...",
"status": "pending",
"sent_at": "2026-03-31T10:05:00+02:00"
}
}
Processus côté signataire :
- Le signataire reçoit un email avec un lien sécurisé
- Il visualise le document PDF et les zones de signature
- Il trace sa signature, à la souris ou au doigt, ou fait écrire son nom en écriture manuscrite et l'adopte comme signature
- Il reçoit un code OTP (par email ou SMS) pour valider
- Le document est signé et un dossier de preuve est généré
Suivi et téléchargement
Consulter le statut
GET /api/v1/sign-requests/{uuid}
// Réponse - statuts possibles : draft, pending, partially_signed, completed, expired, cancelled
{
"data": {
"id": "sr-uuid-...",
"status": "completed",
"subject": "Contrat de bail",
"progress": 100,
"signers": [
{
"id": "signer-uuid-...",
"name": "Jean Dupont",
"email": "jean.dupont@email.com",
"status": "signed",
"otp_channel": "sms",
"signed_at": "2026-03-31T14:30:00+02:00"
}
]
}
}
Télécharger le PDF signé
GET /api/v1/sign-requests/{uuid}/download
Retourne le fichier PDF signé (Content-Type: application/pdf). Disponible uniquement quand le statut est completed.
Télécharger la preuve d'audit
GET /api/v1/sign-requests/{uuid}/proof
Retourne le dossier de preuve PDF (horodatage, IP, empreintes, captures de signature).
Webhooks
Recevez des notifications en temps réel sur votre serveur lorsqu'un événement se produit :
sign_request.sent
Demande envoyée aux signataires
sign_request.completed
Tous les signataires ont signé
sign_request.cancelled
Demande annulée
signer.signed
Un signataire a signé
signer.declined
Un signataire a refusé
signer.identity_verified
Identité du signataire vérifiée (option)
signer.identity_failed
Vérification d’identité refusée, abandonnée ou expirée
Liste complète des événements
| sign_request.sent | Demande envoyée aux signataires |
| sign_request.completed | Tous les signataires ont signé |
| sign_request.cancelled | Demande annulée |
| sign_request.expired | Demande expirée avant que tous aient signé (les signatures non recueillies ne sont pas facturées) |
| signer.signed | Un signataire a signé |
| signer.declined | Un signataire a refusé (motif dans decline_reason) |
| sign_request.relaunched | Demande expirée relancée depuis le site |
| public_form.submitted | Formulaire public rempli et soumis |
| sign_request.submitted_for_approval | Demande soumise à la validation interne (site uniquement) |
| sign_request.approved | Demande validée en interne |
| sign_request.rejected | Demande refusée en interne |
| payment.completed | Paiement du signataire encaissé |
| payment.failed | Paiement du signataire échoué |
| signer.identity_verified | Identité du signataire vérifiée (option) |
| signer.identity_failed | Vérification d’identité refusée, abandonnée ou expirée (option) |
Enregistrer un webhook
POST /api/v1/webhooks
curl -X POST https://www.jurisign.fr/api/v1/webhooks \
-H "Authorization: Bearer VOTRE_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"url": "https://votre-serveur.com/webhooks/jurisign",
"events": ["sign_request.completed", "signer.signed"]
}'
// Réponse 201 - conservez le secret !
{
"data": {
"id": 1,
"url": "https://votre-serveur.com/webhooks/jurisign",
"events": ["sign_request.completed", "signer.signed"],
"secret": "wh_sec_abc123..."
}
}
Vérification de signature
Chaque webhook est signé avec le secret fourni à la création : l'en-tête X-JuriSign-Signature vaut sha256= suivi du HMAC-SHA256, en hexadécimal, du corps brut de la requête. Calculez-le sur les octets reçus, avant tout décodage JSON : un JSON décodé puis réencodé ne donne pas la même signature. Les en-têtes X-JuriSign-Event, X-JuriSign-Timestamp et X-JuriSign-Delivery donnent l'événement, l'heure d'envoi et l'identifiant de livraison. Répondez par un code 2xx ; sinon, 8 nouvelles tentatives sont faites, étalées sur environ 42 heures (après 1 min, 5 min, 15 min, 30 min, 1 h, 4 h, 12 h et 24 h). Le journal de livraison (GET /webhooks/{id}/logs) garde chaque tentative.
Vérifier la signature d'un webhook
PHP (Laravel)
$corps = $request->getContent(); // corps brut
$attendu = 'sha256='.hash_hmac('sha256', $corps, config('services.jurisign.webhook_secret'));
if (! hash_equals($attendu, (string) $request->header('X-JuriSign-Signature'))) {
abort(401);
}
$evenement = json_decode($corps, true); // ex. $evenement['event'] === 'sign_request.completed'
Node.js (Express)
import crypto from 'node:crypto';
import express from 'express';
const app = express();
// express.raw : garder le corps brut, indispensable au calcul
app.post('/webhooks/jurisign', express.raw({ type: 'application/json' }), (req, res) => {
const attendu = 'sha256=' + crypto
.createHmac('sha256', process.env.JURISIGN_WEBHOOK_SECRET)
.update(req.body)
.digest('hex');
const recu = req.get('X-JuriSign-Signature') || '';
if (recu.length !== attendu.length
|| !crypto.timingSafeEqual(Buffer.from(recu), Buffer.from(attendu))) {
return res.sendStatus(401);
}
const evenement = JSON.parse(req.body.toString('utf8'));
res.sendStatus(200);
});
Python (Flask)
import hashlib, hmac, os
from flask import Flask, abort, request
app = Flask(__name__)
@app.post("/webhooks/jurisign")
def webhook_jurisign():
corps = request.get_data() # corps brut
attendu = "sha256=" + hmac.new(
os.environ["JURISIGN_WEBHOOK_SECRET"].encode(), corps, hashlib.sha256
).hexdigest()
if not hmac.compare_digest(attendu, request.headers.get("X-JuriSign-Signature", "")):
abort(401)
evenement = request.get_json()
return "", 200
Java (17+)
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.HexFormat;
static boolean signatureValide(byte[] corps, String enTete, String secret) throws Exception {
Mac mac = Mac.getInstance("HmacSHA256");
mac.init(new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
String attendu = "sha256=" + HexFormat.of().formatHex(mac.doFinal(corps));
return enTete != null && MessageDigest.isEqual(
attendu.getBytes(StandardCharsets.UTF_8), enTete.getBytes(StandardCharsets.UTF_8));
}
C# (.NET 6+)
using System.Security.Cryptography;
using System.Text;
static bool SignatureValide(byte[] corps, string? enTete, string secret)
{
using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secret));
var attendu = "sha256=" + Convert.ToHexString(hmac.ComputeHash(corps)).ToLowerInvariant();
return enTete is not null && CryptographicOperations.FixedTimeEquals(
Encoding.UTF8.GetBytes(attendu), Encoding.UTF8.GetBytes(enTete));
}
Redirection après signature et domaine déclaré
Le champ redirect_url affiche au signataire, une fois sa signature faite, un bouton « Revenir sur votre-site.fr ». Il est facultatif : sans lui, l'API fonctionne entièrement et le signataire voit la page de confirmation JuriSign.
Pour l'utiliser, votre nom de domaine doit être déclaré au préalable auprès du support. Tant qu'aucun domaine n'est déclaré, toute redirect_url est refusée (HTTP 422), et la demande n'est pas créée.
Pourquoi un vrai domaine, déclaré à l'avance ?
- Protéger vos signataires contre l'hameçonnage. Le signataire fait confiance au lien jurisign.fr qu'il vient de recevoir. Si n'importe quelle adresse était acceptée, quiconque ouvre un compte pourrait renvoyer ce signataire vers une copie de votre site, avec la caution de jurisign.fr : c'est une « redirection ouverte », une faille classique.
- Un domaine qui vous appartient. Vos sous-domaines sont acceptés automatiquement. Déclarer une adresse IP, localhost ou le domaine partagé d'un hébergeur (dont d'autres clients utilisent des sous-domaines) autoriserait des sites qui ne sont pas les vôtres.
- https obligatoire, pour que le retour vers votre site ne puisse pas être intercepté.
- Un contrôle humain : c'est ce qui permet de s'assurer que le domaine est bien le vôtre avant de l'accepter.
Pour déclarer votre domaine : écrivez au support en indiquant le nom de votre organisation et le domaine (par exemple votre-site.fr). Pendant vos essais, ou en développement local, envoyez simplement vos demandes sans redirect_url.
Validation OTP / SMS
JuriSign supporte deux canaux de validation OTP pour vérifier l'identité du signataire :
Inclus dans tous les plans
Le code OTP à 6 chiffres est envoyé par email au signataire. Valable 10 minutes, 3 tentatives max.
"otp_channel": "email"
SMS
Plan Professionnel et supérieur
Le code OTP est envoyé par SMS au numéro du signataire. Plus sécurisé, recommandé pour les documents sensibles.
"otp_channel": "sms"
"telephone": "+33612345678"
Format téléphone : Format international avec indicatif pays (ex: +33612345678 pour la France).
Aller plus loin
Rejouer sans risque de doublon : Idempotency-Key
Sur POST /api/v1/sign-requests, l’en-tête facultatif Idempotency-Key (une valeur unique par demande, par exemple un UUID) vous protège des doublons quand le réseau coupe avant la réponse : le même appel rejoué avec la même clé renvoie la réponse d’origine, sans créer de seconde demande. La même clé avec un autre corps est refusée en 409. Une réponse en erreur n’est pas mémorisée : vous pouvez la rejouer telle quelle une fois la cause corrigée.
Retrouver vos références : metadata
L’objet metadata envoyé à la création (par exemple {"ref": "D-2026-042"}) est renvoyé tel quel par GET /sign-requests, GET /sign-requests/{id} et dans chaque webhook. JuriSign y ajoute source et, pour une demande créée depuis un modèle, template_id.
Statuts d’une demande
draft (créée, pas envoyée), pending (envoyée), partially_signed (au moins un signataire a signé), completed, cancelled, expired (webhook sign_request.expired), et pending_approval pour une demande créée sur le site et soumise à la validation interne. Une demande envoyée par l’API n’est jamais retenue pour validation.
Documents demandés au signataire
signers[].attachments_requested : jusqu’à 5 documents par signataire (RIB, pièce d’identité, justificatif…), chacun un libellé ou un objet {"label": "RIB", "required": true}. Le signataire les dépose avant de signer (PDF, JPG ou PNG, 10 Mo au plus) ; ils figurent dans signers[].attachments et se téléchargent par GET /sign-requests/{id}/attachments/{attachment_id}.
Éléments de preuve par signataire
Quand la demande utilise le selfie, le paraphe ou le lieu de signature, GET /sign-requests/{id} renvoie pour chaque signataire evidence : photo prise, empreinte SHA-256 et consentement (selfie), paraphe tracé et consentement (initials), source et position déclarée par l’appareil, précision, consentement et empreinte de l’appareil (location). Jamais l’image du selfie : elle reste dans le dossier de preuve.
Modèles
Créez vos modèles sur le site, ou par l’API : POST /templates (nom, objet, options, signataires, zones et, au choix, document_id pour que le modèle garde sa propre copie du PDF) et PUT /templates/{id} pour les modifier. Les signataires peuvent rester à compléter (prénom, nom et adresse vides) : ils sont alors fournis à chaque usage. Chaque signataire doit avoir au moins une zone de signature. Listez-les par GET /templates. POST /templates/{id}/sign-requests crée une demande en une fois : signers remplace les signataires du modèle rang pour rang, fields pré-remplit les champs texte et cases à cocher (au besoin en lecture seule), et auto_send: true l’envoie aussitôt.
Envoi en masse
Un modèle de fusion (POST /bulk-templates, HTML avec des champs comme {{nom}}), puis une campagne (POST /bulk-campaigns) avec la liste recipients : un document personnalisé et une demande par destinataire. Lancez-la par POST /bulk-campaigns/{id}/launch, suivez-la par GET /bulk-campaigns/{id}, exportez le résultat par GET /bulk-campaigns/{id}/export, relancez les échecs par POST /bulk-campaigns/{id}/retry. La campagne accepte les mêmes options qu’une demande, appliquées à chacune : sender_name, reminders, redirect_url, require_selfie, requires_paraph, require_geolocation et identity_verification.
Formulaires publics
POST /public-forms publie un modèle sous un lien public : chaque personne qui remplit le formulaire reçoit sa propre demande à signer (webhook public_form.submitted). otp_channel impose le canal de vérification (sms ou email) ; daily_submission_limit et expires_at le bornent ; POST /public-forms/{id}/rotate-token change le lien.
Solde et consommation
GET /account/credits donne la formule, les signatures incluses, consommées et restantes. Il donne aussi le solde des crédits de vérification d’identité (identity_credits). Un envoi par l’API n’est jamais bloqué faute de signatures : le dépassement est facturé le mois suivant.
Tous les endpoints
| Méthode | Endpoint | Description |
|---|---|---|
| Authentication | ||
| GET | / | API Status |
| POST | /auth/token | Create API Token |
| DELETE | /auth/token | Revoke Current Token |
| POST | /auth/sandbox-token | Create Sandbox API Token |
| Account | ||
| GET | /account/credits | Get Credit Balance |
| Templates | ||
| GET | /templates | List Sign Request Templates |
| POST | /templates | Create a template |
| GET | /templates/{id} | Get Template |
| DELETE | /templates/{id} | Delete Template |
| PUT | /templates/{id} | Update a template |
| POST | /templates/{id}/sign-requests | Create Sign Request From Template |
| Bulk | ||
| GET | /bulk-templates | List Bulk Templates |
| POST | /bulk-templates | Create Bulk Template |
| GET | /bulk-templates/{id} | Get Bulk Template |
| PUT | /bulk-templates/{id} | Update Bulk Template |
| DELETE | /bulk-templates/{id} | Delete Bulk Template |
| GET | /bulk-campaigns | List Bulk Campaigns |
| POST | /bulk-campaigns | Create Bulk Campaign |
| GET | /bulk-campaigns/{id} | Get Bulk Campaign |
| DELETE | /bulk-campaigns/{id} | Delete Bulk Campaign |
| POST | /bulk-campaigns/{id}/launch | Launch Bulk Campaign |
| POST | /bulk-campaigns/{id}/cancel | Cancel Bulk Campaign |
| POST | /bulk-campaigns/{id}/retry | Retry Failed Recipients |
| GET | /bulk-campaigns/{id}/export | Export Campaign Results |
| Public Forms | ||
| GET | /public-forms | List Public Forms |
| POST | /public-forms | Create Public Form |
| GET | /public-forms/{id} | Get Public Form |
| PUT | /public-forms/{id} | Update Public Form |
| DELETE | /public-forms/{id} | Delete Public Form |
| POST | /public-forms/{id}/rotate-token | Rotate Public Form Token |
| Documents | ||
| GET | /documents | List Documents |
| POST | /documents | Upload Document |
| GET | /documents/{id} | Get Document |
| DELETE | /documents/{id} | Delete Document |
| GET | /documents/{id}/download | Download Document |
| Sign Requests | ||
| GET | /sign-requests | List Sign Requests |
| POST | /sign-requests | Create Sign Request |
| GET | /sign-requests/{id} | Get Sign Request |
| POST | /sign-requests/{id}/send | Send Sign Request |
| POST | /sign-requests/{id}/cancel | Cancel Sign Request |
| POST | /sign-requests/{id}/remind | Remind Signers |
| GET | /sign-requests/{id}/download | Download Signed PDF |
| GET | /sign-requests/{id}/proof | Download Audit Proof |
| GET | /sign-requests/{id}/attachments/{attachment_id} | Telecharger un document depose par un signataire |
| Webhooks | ||
| GET | /webhooks | List Webhook Endpoints |
| POST | /webhooks | Create Webhook Endpoint |
| PUT | /webhooks/{id} | Update Webhook Endpoint |
| DELETE | /webhooks/{id} | Delete Webhook Endpoint |
| GET | /webhooks/{id}/logs | Webhook Delivery Logs |
| POST | /webhooks/{id}/regenerate-secret | Regenerate Webhook Secret |
Gestion des erreurs
L'API retourne des codes HTTP standards avec un corps JSON décrivant l'erreur :
| Code | Signification |
|---|---|
| 200 | Succès |
| 201 | Ressource créée |
| 401 | Token invalide ou expiré |
| 403 | Action non autorisée (organisation suspendue, plan insuffisant) |
| 404 | Ressource non trouvée |
| 422 | Erreur de validation (champs manquants ou invalides) |
| 429 | Rate limit dépassé (trop de requetes) |
| 500 | Erreur serveur interne |
// Exemple d'erreur 422
{
"message": "Les données fournies ne sont pas valides.",
"errors": {
"document_id": ["Le champ document id est requis."],
"signers.0.email": ["L'adresse email est invalide."]
}
}
Support
Documentation interactive
Explorez et testez tous les endpoints en direct avec notre interface Swagger :
Ouvrir Swagger UIContact technique
Pour toute question sur l'intégration :
- Email : support@jurisign.fr
- Site : www.jurisign.fr