Send Direct to DocuSign

What this does

Generate Quik! forms and send them straight to DocuSign as an envelope, skipping the Quik! Form Viewer step. You supply form IDs, prefill data, and recipient information. Quik! handles document rendering, signature placement, role mapping, and the conversation with DocuSign.

When to use this

Pick this flow when:

• You already have complete data and don't need the user to fill in anything by hand.
• You want to skip showing the HTML form viewer.
• You don't want to build or host your own envelope creation service.
• You need draft review capability before sending the envelope.
• You need multiple forms in a single envelope.

If the user needs to fill out or review the form before signing, use the standard Launch a Form flow instead.

How it compares to other DocuSign workflows

Before you start

You need:

• A Quik! account with at least one library subscription. See Library Subscription.
• Your DocuSign account connected to your Quik! Master Account. See Integrations > DocuSign > Connect DocuSign Account.
• A Quik! OAuth Bearer token. See Authentication.

The two-call flow

Sending a Direct to DocuSign envelope is a two-step sequence:

Your app                  Quik! API                   DocuSign
   │                         │                           │
   │  Call 1: Generate  ────▶│                           │
   │     SignData /          │                           │
   │     PrintData           │                           │
   │◀──── PrintData, ────────│                           │
   │      SignData,          │                           │
   │      SignSettings       │                           │
   │                         │                           │
   │  Transform output       │                           │
   │  (parse, reshape)       │                           │
   │                         │                           │
   │  Call 2: Create  ──────▶│  ───── Create envelope ──▶│
   │     envelope            │                           │
   │◀──── EnvelopeId ────────│◀── Envelope sent/drafted ─│

Call 1: Generate SignData and PrintData

You call the standard execute/html endpoint with two extra flags: GenerateSignData: true and GeneratePrintData: true. The request looks like any other form generation request, with prefill data and an ESignType object configured for DocuSign.

What you get back, alongside the normal UNID and form URL, are three serialized JSON strings: PrintData, SignData, and SignSettings. These contain the document content, the tab placements (where signatures and dates go), and the envelope configuration.

For the exact request and response schema, see the API reference.

Transform the output

The three serialized strings need three things before they're ready for Call 2:

1. Parse them. They come back as JSON strings, not objects. Run each through JSON.parse().
2. Rename property keys. Call 1 returns PascalCase (FieldName, XCoord, RoleId). Call 2 expects camelCase (fieldName, xCoord, roleID). Map them as you build the Call 2 body.
3. Reshape into packagesData and signSettings. The Call 1 output maps directly to these two top-level fields in the Call 2 body.

A working JavaScript transformer is available as a starter sample (link out to your code samples repo or wherever Caylent hosts them).

Call 2: Create the envelope

You call the DocuSign envelope creation endpoint with the transformed payload. The response is a DocuSign EnvelopeId.

For the exact request and response schema, see the API reference.

From this point on, the envelope is in DocuSign. Polling for status, downloading the signed document, and routing it to your archive are your responsibility, done by calling DocuSign directly with the EnvelopeId.

Common variations

Send immediately or save as draft

The status field in signSettings controls what happens after the envelope is created.

You can build a direct link to take users to the draft in DocuSign at https://apps.docusign.com/send/prepare/{envelopeId}.

Multiple forms in one envelope

To include more than one form in a single DocuSign envelope, add additional objects to the packagesData array in Call 2. Each package brings its own printData and signData. DocuSign combines them into one envelope and one signing experience for the recipient.

When using Form Group Instances in Call 1 (the dashed QuikFormID syntax), Call 1 returns separate PrintData and SignData for each instance. Pass each through the transformer and stack them in packagesData.

Pitfalls

• Quik! creates the envelope. You handle what happens after. Polling DocuSign for status and downloading the signed document are your team's responsibility, not Quik!'s.
• Don't skip the transform step between calls. The Call 1 output isn't shaped for Call 2 input. Parse the serialized JSON strings, normalize property casing, and reshape into packagesData and signSettings before posting.
• Draft envelopes still count against your DocuSign envelope quota. Saving as "created" does not skip the count. It just suppresses the emails.
• The same person across multiple instances can receive duplicate signing requests if not configured deliberately. When using Form Group Instances and the same recipient appears in more than one instance, configure DocuSign signers so Name, Email, and Order match across the instances. Otherwise DocuSign treats them as separate signers and sends multiple emails. See Concepts > Form Lifecycle > Form Groups and Instances for the signer configuration pattern.

Related articles

Continue with these articles to understand the related concepts and workflows:

• Connect DocuSign account — Set up the DocuSign connection required before sending forms for signature.

• Authentication — Review the secure setup needed for API-based workflows.

• Roles and Role Prefixes — Understand how Quik! roles determine who signs.

• Form Groups and Instances — Learn how signer setup changes when sending packages with multiple instances.