Chaindoc logoChaindoc

Schnellstartanleitung

Mit Chaindoc kannst du in weniger als 10 Minuten loslegen. Dieser Leitfaden behandelt sowohl die Weboberfläche als auch die API-Integration für Entwickler.

Für Endnutzer

Schritt für Schritt: Deine erste Signatur

1AnmeldenErstell dein kostenloses Konto unter app.chaindoc.io. Bestätige deine E-Mail-Adresse.

2Dokument hochladenKlick auf „Neues Dokument“ und lade deine Datei hoch. Unterstützt werden PDF-Dateien, Office-Dokumente und Bilder (bis zu 50 MB).

3Dokumentdetails hinzufügenGib den Namen des Dokuments, eine Beschreibung und Tags zur Organisation ein. Wähle die Zugriffsebene (privat, Team oder öffentlich).

4Signaturanforderung erstellenKlick auf „Unterschriften anfordern“, füge die E-Mail-Adressen der Empfänger hinzu, leg eine Frist fest und passe die Nachricht an.

5Signaturfluss konfigurierenWähle die Signaturreihenfolge (parallel oder sequenziell), aktiviere bei Bedarf KYC und wähle die Benachrichtigungseinstellungen aus.

6Anfrage sendenÜberprüfe alles und schick es ab. Die Leute kriegen dann eine E-Mail mit einem sicheren Link zum Unterschreiben.

7Fortschritt verfolgenBeobachte den Status der Unterschriften in Echtzeit. Lass dich benachrichtigen, wenn Unterschriften gesammelt wurden.

8Unterzeichnetes Dokument herunterladenLade nach Abschluss das signierte Dokument mit Blockchain-Zertifikat herunter.

Für Entwickler

Integrier Chaindoc mit unserer REST-API und unseren SDKs in deine Anwendung.

1. API-Schlüssel abrufen

2. SDK installieren

Such dir das SDK passend zu deinem Anwendungsfall aus:

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

3. Erstelle dein erstes Dokument über die API

server.ts
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);

4. Signaturanforderung erstellen

server.ts
// 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);

5. Signing-Schnittstelle (Frontend) einbauen

Für die eingebettete Signatur in deiner Webanwendung:

// 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. Status verfolgen und Ereignisse bearbeiten

terminal
// Check signature request status
const status = await chaindoc.signatures.getRequestStatus(
  sigRequest.signatureRequest.uuid
);

if (status.signatureRequest.status === 'completed') {
  console.log('All signatures collected!');
  // Download signed document
  // Send notifications
  // Update your database
}

7. Webhooks einrichten (optional)

Erhalte Echtzeit-Benachrichtigungen zu Ereignissen:

webhooks.ts
// 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');
});

Beispiel für einen kompletten Arbeitsablauf

Hier ist ein komplettes Beispiel, das alle Schritte kombiniert:

complete-workflow.ts
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 });

Nächste Schritte

  • Schau dir die Installationsanleitung an, um mehr über die SDK-Einrichtung zu erfahren.
  • Schau dir die API-Dokumentation an, um die komplette Endpunktreferenz zu sehen.
  • Schau in der SDK-Dokumentation nach framework-spezifischen Beispielen (React, Vue, Angular).
  • Richte Webhooks für Echtzeit-Ereignisbenachrichtigungen ein.
  • Schau dir die Sicherheitsempfehlungen für die Produktionsbereitstellung an.

Häufig gestellte Fragen

Wie lange dauert die Blockchain-Verifizierung?

Die Blockchain-Überprüfung dauert normalerweise 1–5 Minuten, je nach Netzwerk. Die Dokumente sind sofort verfügbar, die Überprüfung läuft im Hintergrund.

Kann ich das ohne einen kostenpflichtigen Tarif testen?

Ja! Der kostenlose Tarif beinhaltet den Zugriff auf die Weboberfläche. Für den API-Zugriff brauchst du den Business-Tarif, aber du kannst die Sandbox-Umgebung zum Testen nutzen.

Sind Unterschriften rechtlich bindend?

Ja, Chaindoc-Signaturen entsprechen den Vorschriften von eIDAS, ESIGN Act und UETA. Die Blockchain-Verifizierung liefert zusätzliche rechtliche Beweise.

Welche Dateiformate werden unterstützt?

PDF, DOC, DOCX, XLS, XLSX, PPT, PPTX, TXT, JPG, PNG, GIF, WEBP, SVG, MP4, AVI, MOV, WMV. Maximale Dateigröße: 50 MB.