Documenso Core Workflow BSAFE

Model-agnostic agent-skills platform with a harness-free canonical layer, verified adapters, and the ccpi package manager. Explore at tonsofskills.com.

The instruction file, verbatim from the audited commit — this is the text the model reads, and the surface the audit's instruction layer examines. Quoted here so you can judge it without cloning anything.

---
name: documenso-core-workflow-b
description: 'Implement Documenso template-based workflows and direct signing links.

  Use when creating reusable templates, generating documents from templates,

  or implementing direct signing experiences.

  Trigger with phrases like "documenso template", "signing link",

  "direct template", "reusable document", "template workflow".

  '
allowed-tools: Read, Write, Edit
version: 1.14.0
license: MIT
author: Jeremy Longshore <[email protected]>
tags:
- saas
- documenso
- workflow
compatibility: Designed for Claude Code
---
# Documenso Core Workflow B: Templates & Direct Signing

## Output

- A reviewed template/direct-signing workflow with role-limited access, lifecycle validation, and a safe disable/rollback action.
- A redacted receipt showing environment, document/template version, state transitions, and result.

## Examples

Create a development template with synthetic fields and signer, verify role order, expiration, authentication, signing state, and callback behavior, then disable/archive the test document. Do not use real agreements or signer identity for the walkthrough, and stop promotion if authorization or lifecycle state differs from the review.

## Overview

Create reusable templates, generate documents from templates with prefilled fields, and implement direct signing links for public/anonymous signers. Templates define the PDF, fields, and recipient roles once — then stamp out documents on demand.

## Prerequisites

- Completed `documenso-core-workflow-a`
- At least one PDF uploaded to Documenso as a template
- Understanding of recipient roles and field types

## Instructions

### Step 1: Create a Template via Dashboard

Templates are created in the Documenso UI:

1. Navigate to **Templates** in the sidebar.
2. Click **Create Template** and upload a PDF.
3. Add **placeholder recipients** (e.g., "Signer 1", "Approver") — these become roles that get filled when creating documents from the template.
4. Place fields on the PDF and assign them to placeholder recipients.
5. Save the template and note the **template ID** from the URL.

### Step 2: Create Document from Template (v1 REST API)

```typescript
// The v1 API has a dedicated template endpoint
const templateId = 42; // From the dashboard URL

const res = await fetch(
  `https://app.documenso.com/api/v1/templates/${templateId}/create-document`,
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.DOCUMENSO_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      title: "Service Agreement — Acme Corp",
      recipients: [
        {
          email: "[email protected]",
          name: "Alice CEO",
          role: "SIGNER",
        },
      ],
      // Optionally prefill fields by their IDs
      prefillFields: [
        { id: "field_abc123", value: "2026-03-22" },
        { id: "field_def456", value: "Acme Corporation" },
      ],
    }),
  }
);

const document = await res.json();
console.log(`Created document ${document.documentId} from template ${templateId}`);
```

### Step 3: Template Workflow Patterns

```typescript
// Pattern: Batch document generation from template
async function generateContracts(
  templateId: number,
  clients: Array<{ email: string; name: string; company: string }>
) {
  const results = [];

  for (const client of clients) {
    const res = await fetch(
      `https://app.documenso.com/api/v1/templates/${templateId}/create-document`,
      {
        method: "POST",
        headers: {
          Authorization: `Bearer ${process.env.DOCUMENSO_API_KEY}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          title: `Service Agreement — ${client.company}`,
          recipients: [
            { email: client.email, name: client.name, role: "SIGNER" },
          ],
        }),
      }
    );

    const doc = await res.json();

    // Send immediately after creation
    await fetch(
      `https://app.documenso.com/api/v1/documents/${doc.documentId}/send`,
      {
        method: "POST",
        headers: { Authorization: `Bearer ${process.env.DOCUMENSO_API_KEY}` },
      }
    );

    results.push({ documentId: doc.documentId, client: client.email });
  }

  return results;
}
```

### Step 4: Direct Signing Links

Direct links let anyone sign without receiving an email — perfect for public forms, walk-in signers, or embedded flows.

**Setup in Dashboard:**

1. Open a template.
2. Click **Direct Link** in template settings.
3. Choose which recipient role the direct link signer fills.
4. Copy the generated URL.

**Direct Link URL format:**

```
https://app.documenso.com/sign/direct/{token}
```

**Embedding a Direct Link in an iframe:**

```html
<iframe
  src="https://app.documenso.com/sign/direct/abc123token"
  width="100%"
  height="800"
  frameborder="0"
  allow="clipboard-write"
></iframe>
```

### Step 5: Embedded Signing with React

```bash
npm install @documenso/embed-react
```

```tsx
// DirectSigningPage.tsx
import { EmbedDirectTemplate } from "@documenso/embed-react";

export function DirectSigningPage() {
  return (
    <EmbedDirectTemplate
      token="your-direct-link-token"
      host="https://app.documenso.com"
      // Pre-fill recipient data
      name="Jane Doe"
      email="[email protected]"
      // Lock pre-filled fields so signer can't change them
      lockName={true}
      lockEmail={true}
      // Callbacks
      onDocumentReady={() => console.log("Document loaded")}
      onDocumentCompleted={() => console.log("Signing complete!")}
      onDocumentError={(err) => console.error("Error:", err)}
    />
  );
}
```

### Step 6: Embedded Authoring (Document Editor)

Let users create and edit documents directly in your app:

```tsx
import { EmbedCreateDocument } from "@documenso/embed-react";

export function CreateDocumentPage() {
  return (
    <EmbedCreateDocument
      presignToken="presign-token-from-api"
      host="https://app.docu

SAFEgrade B · trust 89/100 Nothing in the source contradicts what it says it does. Grade A is reserved for packages that have also passed the behavioural sandbox.

What the source does

Filesystem

none-observed

Network

none-observed

Shell

none-observed

Dependencies

pinned

Secrets in source

found

Findings (1)

token="your-direct-link-token"

Gates applied: no_behavioural_pass.