Templates

Templates are the backbone of repeatable signing workflows. They let you define roles, field placement, and optional preFillKey values once, then reuse that structure for every new document.

Why templates matter

Templates give you a stable contract between your team and your integrations:

• Roles define who should sign without tying the template to a specific person
• Fields stay in consistent locations on the PDF
• Pre-fill keys let your app populate values programmatically

If you plan to automate document creation, build a solid template first.

Create a template

You can start in two ways:

Upload a new PDF

1. Open Templates
2. Click Upload Template
3. Name the template
4. Upload the PDF
5. Configure roles and fields in the editor

Save an existing document as a template

If you already configured a document manually:

1. Open it in the editor
2. Click Save as Template
3. Choose a template name

Papyrus keeps the layout and field positions, but replaces real recipients with recipient roles.

Design strong recipient roles

A good role label should describe responsibility, not a person's identity.

Examples:

When you later create a document from the template, you map each role label to a real signer. For API-driven workflows, roleLabel is the stable mapping key, so avoid renaming roles casually once an integration depends on them.

Configure fields

After the PDF is in the template editor:

1. Place each field on the page
2. Assign it to the correct role
3. Set required or optional behavior
4. Configure any dropdown options
5. Save the template

Use preFillKey on fields when your application should supply data at document creation time.

When to use preFillKey

Add a pre-fill key when the same kind of value will be passed repeatedly, such as:

• company_name
• customer_address
• order_number
• effective_date

Your API request later sends those values inside preFillValues. The keys must match the template's preFillKey values exactly.

Create a document from a template

From the dashboard:

1. Open the template
2. Click New Document
3. Name the new document
4. Fill in real recipient details for each role
5. Send it when ready

From the API:

1. Fetch the template if you need its roles or fields
2. Call the create-from-template endpoint
3. Pass a recipients array where each recipient object includes a roleLabel
4. Optionally pass name, signingOrder, preFillValues, externalId, expiresInDays, and delivery settings

For basic email signing, you can keep each recipient minimal: roleLabel, name, and email are enough unless you want extra signer authentication.

Use signingOrder: "parallel" when everyone can sign immediately. Use signingOrder: "sequential" when each signer must wait for the previous signer to finish.

For the HTTP details, use API Authentication and the API Reference.

Use direct links when the signer starts the flow

Direct links are useful for self-serve signing, such as:

• Intake packets
• Waivers
• Consent forms
• Onboarding agreements

When a direct link is enabled:

1. Papyrus generates a reusable public URL
2. A signer opens the link and completes the flow
3. Papyrus creates a new document from the template automatically

Direct links work best with single-recipient templates. For more controlled or multi-recipient flows, create documents from the API instead.

See Embed Integration for the embedding decision tree and security recommendations.

Manage template changes safely

You can rename, edit, or delete templates from the templates area.

The important rule is:

• Editing a template changes future documents
• It does not change documents that were already created from it

That makes templates safe to evolve over time without rewriting existing audit history.

Finding templates later

Use the templates list to:

• Search by template name
• Sort by name or created date
• Open the detail view for roles, field counts, and pre-fill keys

Where to go next

• Creating Documents - the draft workflow once a template becomes a document
• Sending for Signature - what happens after creation
• Embed Integration - direct links and embedded signing flows
• API Authentication - using templates from your backend
• API Reference - exact template and create-from-template operations