Bulk send e-signature documents

import { readFileSync } from 'fs';

const CONCURRENCY = 10; // stay within rate limits
const recipients = [
  { name: 'Alice Johnson', email: 'alice@acme.com' },
  { name: 'Bob Smith',     email: 'bob@widget.co' },
  // ... hundreds more
];

async function sendOne(recipient, pdf, token, batchId) {
  const form = new FormData();
  form.append('document', new Blob([pdf], { type: 'application/pdf' }), 'offer.pdf');
  form.append('signers',  JSON.stringify([{ name: recipient.name, email: recipient.email }]));
  form.append('fields',   JSON.stringify([{ type: 'signature', page: 2, x: 240, y: 620 }]));
  form.append('metadata', JSON.stringify({ batch_id: batchId })); // echo'd in webhook

  const env = await fetch('https://api.getsigned.app/v1/envelopes', {
    method: 'POST', headers: { Authorization: `Bearer ${token}` }, body: form,
  }).then(r => r.json());

  await fetch(`https://api.getsigned.app/v1/envelopes/${env.id}/send`, {
    method: 'POST', headers: { Authorization: `Bearer ${token}` },
  });

  return env.id;
}

// Run with CONCURRENCY-limited parallelism
const pdf     = readFileSync('offer-letter.pdf');
const batchId = crypto.randomUUID();
const results = [];

for (let i = 0; i < recipients.length; i += CONCURRENCY) {
  const batch = recipients.slice(i, i + CONCURRENCY);
  const ids   = await Promise.all(batch.map(r => sendOne(r, pdf, token, batchId)));
  results.push(...ids);
  console.log(`Sent ${results.length}/${recipients.length}`);
}

What is bulk send for e-signatures?

Bulk send sends the same document template to multiple recipients in a single operation. Each recipient receives their own independent envelope and unique signing link — not a shared document. When each person signs, their envelope is sealed individually and a completion webhook is fired for that envelope. Bulk send is different from multi-signer routing, where multiple parties all sign the same envelope.

How does bulk send differ from multi-signer routing?

In multi-signer routing, multiple signers all sign the same envelope — the document is sealed only after all signers complete. In bulk send, each recipient gets their own envelope: independent, sealed separately, with its own audit trail and completion webhook. Use multi-signer for contracts that require multiple parties to sign one document; use bulk send when each recipient is signing their own copy.

How do I implement bulk send via the GetSigned API?

GetSigned does not currently expose a single bulk-send endpoint — you create one envelope per recipient via POST /v1/envelopes, then POST /v1/envelopes/{id}/send for each. This is intentional: each envelope is independent with its own ID, audit trail, and lifecycle. For large batches, fan out the creation calls concurrently (Node.js Promise.all, Python asyncio.gather, Go goroutines) and handle rate limits with a concurrency limiter.

What is the rate limit for creating envelopes in bulk?

Rate limits depend on your plan. Contact support for burst limits relevant to your use case. For large batches, implement an exponential backoff retry on 429 responses and cap concurrency to stay within limits — typically 10–20 concurrent envelope creation requests is safe across all plans.

How do I track completion for a large bulk send?

Subscribe to the envelope.completed webhook — it fires per envelope as each recipient completes signing. Store a batch_id (your own identifier) in the envelope's metadata field when creating it; the webhook payload echoes it back so you can correlate completions to your batch. For a progress dashboard, poll GET /v1/envelopes with a filter on your batch_id or query your database of created envelope IDs.