JuriSign

Guide d'intégration API

Intégrez la signature électronique dans vos applications

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 :

1

Upload PDF

POST /documents

→
2

Créer demande

POST /sign-requests

→
3

Envoyer

POST /sign-requests/{id}/send

→
4

Suivi & DL

GET + webhooks

Pas encore de clé ?

Obtenez un accès bac à sable gratuit — aucune signature réelle, aucun crédit décompté.

Obtenir ma clé de test
1

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.

2

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_idUUID du document (requis)
subjectObjet de la demande (requis)
messageMessage pour les signataires
signing_order_type0 = simultané, 1 = séquentiel
expiry_hoursDurée de validité (1 à 720 h)
remindersRelances automatiques par e-mail (J+1, J+3, J+5, veille de l’expiration) : false pour les désactiver. Par défaut true.
sender_nameFacultatif, 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_sendtrue : envoie les invitations dès la création, sans second appel à /send. Par défaut false.
requires_paraphtrue : chaque signataire trace un paraphe, distinct de sa signature, apposé en bas de chaque page. Par défaut false.
require_selfietrue : chaque signataire prend une photo de lui, jointe au dossier de preuve. Par défaut false.
identity_verificationtrue : 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_geolocationtrue : 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

prenomPrénom (requis)
nomNom (requis)
emailEmail (requis)
otp_channel"email" ou "sms"
telephoneRequis 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.

3

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 :

  1. Le signataire reçoit un email avec un lien sécurisé
  2. Il visualise le document PDF et les zones de signature
  3. Il trace sa signature, à la souris ou au doigt, ou fait écrire son nom en écriture manuscrite et l'adopte comme signature
  4. Il reçoit un code OTP (par email ou SMS) pour valider
  5. Le document est signé et un dossier de preuve est généré
4

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.sentDemande envoyée aux signataires
sign_request.completedTous les signataires ont signé
sign_request.cancelledDemande annulée
sign_request.expiredDemande expirée avant que tous aient signé (les signatures non recueillies ne sont pas facturées)
signer.signedUn signataire a signé
signer.declinedUn signataire a refusé (motif dans decline_reason)
sign_request.relaunchedDemande expirée relancée depuis le site
public_form.submittedFormulaire public rempli et soumis
sign_request.submitted_for_approvalDemande soumise à la validation interne (site uniquement)
sign_request.approvedDemande validée en interne
sign_request.rejectedDemande refusée en interne
payment.completedPaiement du signataire encaissé
payment.failedPaiement du signataire échoué
signer.identity_verifiedIdentité du signataire vérifiée (option)
signer.identity_failedVé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 :

Email

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/tokenCreate API Token
DELETE/auth/tokenRevoke Current Token
POST/auth/sandbox-tokenCreate Sandbox API Token
Account
GET/account/creditsGet Credit Balance
Templates
GET/templatesList Sign Request Templates
POST/templatesCreate a template
GET/templates/{id}Get Template
DELETE/templates/{id}Delete Template
PUT/templates/{id}Update a template
POST/templates/{id}/sign-requestsCreate Sign Request From Template
Bulk
GET/bulk-templatesList Bulk Templates
POST/bulk-templatesCreate 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-campaignsList Bulk Campaigns
POST/bulk-campaignsCreate Bulk Campaign
GET/bulk-campaigns/{id}Get Bulk Campaign
DELETE/bulk-campaigns/{id}Delete Bulk Campaign
POST/bulk-campaigns/{id}/launchLaunch Bulk Campaign
POST/bulk-campaigns/{id}/cancelCancel Bulk Campaign
POST/bulk-campaigns/{id}/retryRetry Failed Recipients
GET/bulk-campaigns/{id}/exportExport Campaign Results
Public Forms
GET/public-formsList Public Forms
POST/public-formsCreate 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-tokenRotate Public Form Token
Documents
GET/documentsList Documents
POST/documentsUpload Document
GET/documents/{id}Get Document
DELETE/documents/{id}Delete Document
GET/documents/{id}/downloadDownload Document
Sign Requests
GET/sign-requestsList Sign Requests
POST/sign-requestsCreate Sign Request
GET/sign-requests/{id}Get Sign Request
POST/sign-requests/{id}/sendSend Sign Request
POST/sign-requests/{id}/cancelCancel Sign Request
POST/sign-requests/{id}/remindRemind Signers
GET/sign-requests/{id}/downloadDownload Signed PDF
GET/sign-requests/{id}/proofDownload Audit Proof
GET/sign-requests/{id}/attachments/{attachment_id}Telecharger un document depose par un signataire
Webhooks
GET/webhooksList Webhook Endpoints
POST/webhooksCreate Webhook Endpoint
PUT/webhooks/{id}Update Webhook Endpoint
DELETE/webhooks/{id}Delete Webhook Endpoint
GET/webhooks/{id}/logsWebhook Delivery Logs
POST/webhooks/{id}/regenerate-secretRegenerate Webhook Secret

Gestion des erreurs

L'API retourne des codes HTTP standards avec un corps JSON décrivant l'erreur :

CodeSignification
200Succès
201Ressource créée
401Token invalide ou expiré
403Action non autorisée (organisation suspendue, plan insuffisant)
404Ressource non trouvée
422Erreur de validation (champs manquants ou invalides)
429Rate limit dépassé (trop de requetes)
500Erreur 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 UI

Contact technique

Pour toute question sur l'intégration :

© 2026 PCFRANCE. Logiciel protégé, code source déposé à l'INPI (e-Soleau n° DSO2026035022). Toute contrefaçon sera poursuivie.