If you’re tired of chasing signatures or drowning in document workflows, you’re not alone. This guide is for anyone who wants to automate sending lots of documents for signature—think HR forms, sales contracts, NDAs—without sinking hours into manual labor. We’ll walk through how to use the Signrequest API to set up bulk document signing, save time, and avoid the common headaches.
You don’t need to be a software engineer, but you should be comfortable with basic scripting and APIs. If you can run curl, write a little Python, or tinker with Postman, you’re good.
Why Automate Bulk Document Signing?
Let’s be blunt: manually sending out dozens (or hundreds) of documents for signature is soul-crushing. You lose track of who’s signed what, waste time sending reminders, and inevitably make mistakes. Automating this with an API isn’t just about speed—it’s about accuracy and keeping your sanity.
Signrequest makes e-signatures straightforward, but their web dashboard isn’t built for bulk jobs. The API is, though. With it, you can:
- Send hundreds of documents in one go
- Track who signed and who didn’t
- Send automated reminders
- Pull signed documents back into your system
But the docs can be a bit opaque, and there are gotchas. Here’s how to actually get it working.
Step 1: Get Your Signrequest API Credentials
First things first: you’ll need an API token. Signrequest’s API isn’t open—you need a paid account and API access enabled.
To get your token:
- Log in to your Signrequest dashboard.
- Go to Settings → API & Integrations.
- Generate an API token.
- Copy it somewhere safe. (If you lose it, you’ll have to generate a new one.)
Pro tip: Use a test workspace or sandbox if you can. You don’t want to spam real people while you’re experimenting.
Step 2: Understand the API Basics (Don’t Skip This)
Before you write code, get familiar with the API’s main concepts:
- Document: The actual file you want signed (PDF, DOCX, etc.).
- Signrequest: A signing request sent to a person (or multiple people) for a specific document.
- Template: A pre-configured document where you’ve already placed signature fields.
For bulk sending, you’ll mostly be creating lots of Signrequests—either from scratch or using a template. The API is RESTful and uses standard HTTP verbs (POST, GET, etc.). Most requests and responses are JSON.
The docs: https://signrequest.com/api/v1/docs/ (Bookmark this. You’ll need it.)
Step 3: Prepare Your Document (or Template)
You have two options:
Option 1: Use a Template
This is easier if everyone’s signing the same type of document (e.g., an NDA).
- Upload your document via the Signrequest web app.
- Place signature fields where you want them.
- Save it as a template.
Why use templates? - No need to rebuild signature fields for every request. - Less code to maintain. - Fewer mistakes.
Option 2: Upload On-the-Fly
If you need to customize each document (e.g., personalize each contract), you’ll need to upload each one via the API.
- More flexible, but more work.
- Watch out for rate limits and file size restrictions.
What works? For 90% of bulk jobs, templates are the way to go. Only upload on-the-fly if you truly need per-document customization.
Step 4: Build Your Bulk Sending Script
You can use any language, but Python is popular because it has good HTTP libraries and is easy to read. Here’s a basic workflow:
- Prepare a CSV or spreadsheet with signer names and emails.
- Loop through the list and, for each signer:
- Create a Signrequest (from a template or with a new doc)
- Send it
Here’s a stripped-down Python example using the requests library and a template:
python import requests import csv
API_TOKEN = 'YOUR_API_TOKEN' TEMPLATE_ID = 'YOUR_TEMPLATE_ID' API_URL = 'https://signrequest.com/api/v1/signrequest-templates/'
headers = { 'Authorization': f'Token {API_TOKEN}', 'Content-Type': 'application/json' }
with open('signers.csv') as csvfile: reader = csv.DictReader(csvfile) for row in reader: payload = { 'signers': [ { 'email': row['email'], 'first_name': row['first_name'], 'last_name': row['last_name'] } ], 'from_email': 'you@yourdomain.com', 'subject': 'Please sign this document', 'message': 'Let me know if you have questions.' } response = requests.post( f'{API_URL}{TEMPLATE_ID}/signrequest-quick-create/', headers=headers, json=payload ) if response.status_code == 201: print(f"Sent to {row['email']}") else: print(f"Error for {row['email']}: {response.text}")
What to watch for:
- API rate limits (throttle your requests—don’t blast hundreds per second).
- Handle errors gracefully (invalid emails, etc.).
- The API returns lots of info—log the signrequest_id for tracking.
Step 5: Track Signatures and Send Reminders
Sending is only half the battle. You’ll want to know who’s signed and who hasn’t.
To check signature status:
- Use the
/signrequests/endpoint to get the status of each request. - Poll this endpoint or set up webhooks (if you want real-time updates).
Example (Python):
python response = requests.get( 'https://signrequest.com/api/v1/signrequests/?signer_email=someone@email.com', headers=headers ) data = response.json() for sr in data['results']: print(f"{sr['signers'][0]['email']}: {sr['signers'][0]['status']}")
Reminders:
Signrequest can send automated reminders, but you can also trigger them via the API if you want more control.
- Use the
/signrequests/{id}/send_reminder/endpoint. - Handy if someone’s ignoring your emails.
Step 6: Download Signed Documents
Once everyone’s signed, you probably want the completed docs back in your system.
- Use the
/signrequests/{id}/download/endpoint. - You get a PDF file with signatures and an audit trail.
Python example:
python def download_signed_document(signrequest_id, filename): url = f"https://signrequest.com/api/v1/signrequests/{signrequest_id}/download/" response = requests.get(url, headers=headers) if response.status_code == 200: with open(filename, 'wb') as f: f.write(response.content) print(f"Downloaded {filename}") else: print(f"Failed to download: {response.status_code}")
download_signed_document('abc123', 'signed_doc.pdf')
What to ignore:
Don’t try to parse PDFs or extract signatures yourself. Use the files as-is, unless you have a compelling reason—otherwise, you’re just making your life harder.
Step 7: Handle the Real-World Gotchas
Automation is great, but there are always wrinkles. Here’s what trips people up:
- Email deliverability: Some emails will land in spam. Nothing you can do about it except warn your signers.
- Signer mistakes: People mistype their email or ignore your requests. Build a way to re-send or edit signers.
- Document versions: If you change the template, old links may break or confuse signers. Version your templates.
- API changes: Signrequest’s API is pretty stable, but always check their changelog before updating scripts.
Pro tip:
Start small. Send five documents to yourself and a few friends. Work out the kinks before you go big.
When Not to Use the API
The API is powerful, but don’t overcomplicate things. If you’re only sending a handful of documents per week, the web dashboard is easier. The API shines when you have:
- Dozens or hundreds of documents to send
- A need to integrate with your own systems (HR, CRM, etc.)
- Regular, repeatable processes
If you’re spending more time writing code than you would clicking “Send” a few times, reconsider.
Wrapping Up: Keep It Simple, Iterate Fast
Automating bulk document signing isn’t glamorous, but it frees you up for better work. Start with a template, a CSV, and a simple script. Expect hiccups—don’t try to perfect everything on the first go. As you find what works, add features (like reminders or webhook alerts), but don’t build a Rube Goldberg machine. The goal is less hassle, not more.
You’ll save hours, avoid mistakes, and keep your process moving. That’s the real win.