Guide de démarrage rapide

Mettez Chaindoc en route en moins de 10 minutes. Ce guide vous accompagne à travers l'interface web et l'API, pour que vous puissiez choisir le chemin qui vous convient.

Signer via l'interface web

Vous n'avez besoin d'aucun code pour envoyer votre première demande de signature. L'application web gère tout: l'upload, les destinataires, le flux de signature et la vérification blockchain.

Étape par étape: votre première signature

Vous voulez comprendre les différents types de signatures (simple, avancée, qualifiée)? C'est important pour la conformité. La plupart des contrats commerciaux fonctionnent bien avec des signatures électroniques simples, mais les industries réglementées ont souvent besoin de signatures avancées ou qualifiées.

Intégration via l'API

Si vous intégrez la signature dans votre propre application, vous utiliserez l'API REST et les SDK TypeScript. Le flux est le même que l'interface web, juste automatisé.

1. Obtenez vos clés API

L'accès à l'API nécessite un plan Business. Allez dans Settings > API Access dans votre tableau de bord et créez deux clés:

• Clé publique (`pk_`) pour l'utilisation frontend avec l'Embed SDK
• Clé secrète (`sk_`) pour l'utilisation backend avec le Server SDK. Gardez celle-ci hors du code côté client.

2. Installez le SDK

Choisissez le SDK qui correspond à votre cas d'usage. La plupart des applications ont besoin des deux: le Server SDK pour créer des documents et l'Embed SDK pour l'interface de signature.

# Node.js 18+ required
npm install @chaindoc_io/server-sdk

Pour la configuration détaillée par framework (React, Vue, Angular, Next.js), consultez le guide d'installation.

3. Téléchargez et créez un document

import { Chaindoc } from '@chaindoc_io/server-sdk';
import { readFile } from 'fs/promises';

// Initialize SDK
const chaindoc = new Chaindoc({
  secretKey: process.env.CHAINDOC_SECRET_KEY!,
});

// 1. Upload document
const buffer = await readFile('./contract.pdf');
const file = new Blob([buffer], { type: 'application/pdf' });
const { media } = await chaindoc.media.upload([file]);

// 2. Create document record
const doc = await chaindoc.documents.create({
  name: 'Service Agreement',
  description: 'Q4 2024 Contract',
  media: media[0],
  status: 'published', // Triggers blockchain verification
  hashtags: ['#contract', '#2024'],
  meta: [{ key: 'client', value: 'Acme Corp' }],
});

console.log('Document created:', doc.documentId);

Définir `status: 'published'` déclenche automatiquement la vérification blockchain. Si vous voulez attendre, utilisez `'draft'` et publiez plus tard.

4. Créez une demande de signature

// Create signature request for multiple signers
const sigRequest = await chaindoc.signatures.createRequest({
  versionId: doc.document.versions[0].uuid,
  recipients: [
    { email: 'signer1@example.com' },
    { email: 'signer2@example.com' },
  ],
  deadline: new Date('2024-12-31'),
  message: 'Please review and sign this agreement',
  embeddedFlow: true, // Enable for frontend integration
});

console.log('Signature request created:', sigRequest.signatureRequest.uuid);

Définissez `embeddedFlow: true` si vous allez afficher l'interface de signature dans votre application. Sans cela, les signataires reçoivent un lien vers la page de signature hébergée de Chaindoc.

5. Affichez l'interface de signature (frontend)

Ceci est optionnel. Si vous avez défini `embeddedFlow: true`, vous pouvez ouvrir l'interface de signature directement dans votre application. D'abord, créez une session sur le backend, puis passez l'ID de session au frontend.

// Create embedded session for signer
const session = await chaindoc.embedded.createSession({
  email: 'signer1@example.com',
  metadata: {
    documentId: doc.documentId,
    signatureRequestId: sigRequest.signatureRequest.uuid,
  },
});

// Return sessionId to frontend
res.json({ sessionId: session.sessionId });

6. Vérifiez le statut et écoutez les événements

Vous pouvez interroger le statut, mais les webhooks sont une meilleure option pour la production. Ils notifieront votre serveur dès que quelque chose se produit.

// Poll approach (fine for testing)
const status = await chaindoc.signatures.getRequestStatus(
  sigRequest.signatureRequest.uuid
);

if (status.signatureRequest.status === 'completed') {
  console.log('All signatures collected!');
}

7. Configurez les webhooks (recommandé)

Les webhooks poussent les événements vers votre serveur en temps réel, pour que vous n'ayez pas à vérifier constamment. Voici un gestionnaire Express de base:

// Configure webhook endpoint
app.post('/webhooks/chaindoc', (req, res) => {
  const event = req.headers['x-webhook-event'];
  const payload = req.body;
  
  switch (event) {
    case 'document.verified':
      console.log('Document verified on blockchain:', payload.txHash);
      break;
    case 'signature.request.completed':
      console.log('All signatures collected!');
      // Send notifications, update status, etc.
      break;
  }
  
  res.status(200).send('OK');
});

En production, vous devriez vérifier les signatures des webhooks avec HMAC pour vous assurer que la charge utile provient bien de Chaindoc. Le guide des webhooks couvre cela en détail.

Exemple complet de flux de travail

Ceci rassemble tout: upload, création, signature, vérification. Copiez-le, remplacez par vos clés API, et vous avez un prototype fonctionnel.

import { Chaindoc } from '@chaindoc_io/server-sdk';
import { readFile } from 'fs/promises';

async function createSigningWorkflow() {
  const chaindoc = new Chaindoc({
    secretKey: process.env.CHAINDOC_SECRET_KEY!,
  });
  
  // Step 1: Upload document
  const buffer = await readFile('./contract.pdf');
  const file = new Blob([buffer], { type: 'application/pdf' });
  const { media } = await chaindoc.media.upload([file]);
  
  // Step 2: Create document
  const doc = await chaindoc.documents.create({
    name: 'Service Agreement',
    description: 'Contract for consulting services',
    media: media[0],
    status: 'published',
    hashtags: ['#contract'],
    meta: [],
  });
  
  // Step 3: Create signature request
  const sigRequest = await chaindoc.signatures.createRequest({
    versionId: doc.document.versions[0].uuid,
    recipients: [{ email: 'signer@example.com' }],
    deadline: new Date('2024-12-31'),
    embeddedFlow: true,
  });
  
  // Step 4: Create session for frontend
  const session = await chaindoc.embedded.createSession({
    email: 'signer@example.com',
    metadata: {
      documentId: doc.documentId,
      signatureRequestId: sigRequest.signatureRequest.uuid,
    },
  });
  
  return {
    documentId: doc.documentId,
    sessionId: session.sessionId,
  };
}

// Usage
const { documentId, sessionId } = await createSigningWorkflow();
console.log('Ready for signing:', { documentId, sessionId });

Prochaines étapes

Maintenant que vous maîtrisez les bases, voici ce qu'il faut approfondir selon ce que vous construisez:

• Installation — configuration spécifique par framework pour React, Vue, Angular et Next.js
• Documentation API — référence complète des endpoints avec exemples de requêtes/réponses
• SDKs — Server SDK et Embed SDK, avec guides d'intégration par framework
• Webhooks — notifications d'événements en temps réel pour les applications de production
• Bonnes pratiques de sécurité — ce qu'il faut sécuriser avant de passer en production

Questions fréquentes

Combien de temps prend la vérification blockchain?

Généralement 1 à 5 minutes, selon le réseau. Votre document est disponible immédiatement cependant. La vérification s'exécute en arrière-plan et vous recevrez un événement webhook quand elle est terminée.

Puis-je tester l'API sans payer?

Le plan gratuit vous donne accès à l'interface web. L'accès à l'API nécessite un plan Business, mais l'environnement sandbox vous permet de tout tester sans affecter les données réelles ni utiliser votre quota.

Ces signatures sont-elles juridiquement contraignantes?

Oui. Les signatures Chaindoc sont conformes à l'eIDAS en Europe, au ESIGN Act et à l'UETA aux États-Unis, et aux réglementations équivalentes dans la plupart des autres juridictions. La vérification blockchain ajoute une couche supplémentaire de preuve, ce qui peut être important en cas de litige. Consultez la documentation des signatures pour les détails sur quel type de signature correspond à vos besoins de conformité.

Quels formats de fichier puis-je télécharger?

PDF, DOC, DOCX, XLS, XLSX, PPT, PPTX, TXT, JPG, PNG, GIF, WEBP, SVG, MP4, AVI, MOV et WMV. La taille maximale est de 50MB.