# DocuSign MCP MCP

> DocuSign MCP connects your AI agents directly to document signing workflows. You can manage contract templates, track which recipients have signed, send new agreements, and void requests—all from a single prompt. It handles the entire lifecycle of digital contracts.

## Overview
- **Category:** industry-titans
- **Price:** Free
- **Tags:** electronic-signature, contract-lifecycle, digital-agreements, envelope-tracking, compliance, signing-workflow

## Description

This connector lets you automate everything related to getting documents signed. Need to know who hasn't looked at that NDA yet? Or maybe you just need to spin up a standard service agreement using a pre-approved template? You can do all that without opening a web portal.

Your agent handles the whole process: it first pulls available templates, then builds new envelopes from those models. It tracks every recipient's progress and gives you immediate status updates. If things go sideways, you can void an envelope instantly. The real value shows up when you chain this MCP with others; for example, linking a CRM to send the contract only after a sales deal closes. This complex orchestration is managed reliably through Vinkius, ensuring your credentials pass through a zero-trust proxy so your keys never sit on disk.

## Tools

### get_envelope
Pulls all the specific details about a single document package that was sent out for signatures.

### get_signing_url
Creates and provides a unique, temporary link for a recipient to sign an agreement right away.

### get_template
Retrieves the full details of one specific pre-built document template you plan to use.

### list_envelopes
Lists all document packages, allowing you to filter by date range or other criteria.

### list_folders
Shows the directory structure where your signed agreements are organized and stored.

### list_recipients
Pulls a list of every person who is supposed to sign a specific contract package.

### list_templates
Displays all available, ready-to-use document templates within your account library.

### search_envelopes
Searches for specific documents across your entire record set using keywords or phrases.

### send_envelope
Takes a defined document package and sends it out to the recipients for signature immediately.

### void_envelope
Cancels an active or pending contract request, ensuring no one can sign it anymore.

## Prompt Examples

**Prompt:** 
```
Show me all envelopes from the last 30 days.
```

**Response:** 
```
Found 8 envelopes:

1. **NDA - Acme Corp** — ✅ Completed
2. **Service Agreement** — ⏳ Awaiting signature
3. **Employment Contract** — ✅ Completed
...
```

**Prompt:** 
```
Generate a signing link for the pending contract.
```

**Response:** 
```
🔗 Signing URL generated:

https://docusign.net/signing/xxxx

This link expires in 5 minutes.
```

**Prompt:** 
```
List all available templates.
```

**Response:** 
```
5 templates available:

1. **Standard NDA** — 2 recipients
2. **Service Agreement** — 3 recipients
3. **Employment Offer** — 1 recipient
...
```

## Capabilities

### Track all signing progress
The agent gives you a real-time status report on every sent document, telling you who has signed and who hasn't.

### Build contracts from templates
You can pull standard documents from a library of pre-built templates to quickly create new signing packages.

### Send secure links instantly
Generate immediate, time-limited URLs that allow recipients to sign the contract without needing to log in or navigate complex steps.

### Search and retrieve old contracts
Quickly find specific envelopes by searching text within their details, saving you from wading through months of records.

### Manage contract cleanup
If a deal falls through, the agent can void an envelope to cancel pending signature requests immediately.

## Use Cases

### The Quarterly Compliance Audit
A compliance officer needs to know which employees signed their annual agreements in the last quarter. The agent calls `list_envelopes` (with a date range) and then iterates through each record, using `get_envelope` data to build a single report showing completion status.

### Handling a Failed Deal
The sales team loses the deal. Instead of leaving pending contracts hanging in limbo, an agent calls `void_envelope` immediately after confirming the cancellation, preventing anyone from signing something that's now useless.

### Bulk Onboarding for New Hires
When 10 people start on Monday, a manager needs to send them all their contracts. The agent uses `list_templates` to find the standard employment contract, then calls `send_envelope` with a single payload containing all ten recipients.

### Mid-Process Review
A lawyer needs to confirm who is supposed to sign a specific document before sending it. The agent uses `list_recipients` on the envelope ID, confirming every necessary party is included in the workflow.

## Benefits

- Eliminate manual tracking. Use `list_envelopes` or `search_envelopes` to pull status reports on dozens of contracts in seconds, instead of opening multiple dashboards and clicking through dates.
- Speed up onboarding. Instead of drafting new agreements every time, use `list_templates` to find standard documents and `send_envelope` to deploy them instantly.
- Secure access for recipients. The agent can call `get_signing_url` to generate temporary links, letting people sign from their phone without needing complex setup or logins.
- Maintain compliance. Need proof of what was sent? You can use `list_folders` and `get_envelope` data to build an auditable trail for every document interaction.
- Control the flow. If a contract needs to stop, calling `void_envelope` instantly cancels all pending signatures, preventing accidental commitments.

## How It Works

The bottom line is: you tell the agent the business need (e.g., 'Get Acme Corp to sign this'), and it handles all the underlying steps to make it happen.

1. First, tell your AI agent what you need—like listing all envelopes from last month or checking if a specific template exists.
2. Next, the agent executes the necessary API calls to build the contract package and generates a secure signing link for the intended recipient(s).
3. Finally, it returns the structured data—whether that's the list of recipients or the final status—so your workflow continues.

## Frequently Asked Questions

**How do I find all my agreements from last month using list_envelopes?**
You tell your agent to use `list_envelopes` and provide a start date and end date in ISO format. The agent handles the filtering, giving you an immediate summary of everything sent.

**What is the difference between get_template and list_templates?**
Use `list_templates` to see *all* available document types in your library. Use `get_template` when you know the ID of a specific template and need its detailed structure.

**Can I cancel an envelope using void_envelope if it’s already sent?**
Yes, provided you give the agent a valid reason. The `void_envelope` tool cancels pending signature requests, preventing anyone from signing an agreement that's no longer relevant.

**I need to generate a link for a specific person; should I use get_signing_url?**
Yes, `get_signing_url` is the correct tool. You just provide the envelope ID and the recipient's details, and it generates a secure, actionable signing URL.

**If I only remember a keyword from a contract, how do I find it using `search_envelopes`?**
You can search envelopes by text content directly. This tool allows you to pull up documents even if you don't know the exact name or date range. Simply pass your keywords, and the MCP will filter through all available envelope data for matches.

**What is required when I use `send_envelope` to create a brand new contract?**
You must provide a complete JSON definition for the envelope. This includes knowing which templates to use and specifying the recipients' details up front. Once you pass this structure, your agent sends the package immediately for signature.

**How do I check the folder organization for my documents using `list_folders`?**
The tool returns a hierarchical list of all available envelope folders. This lets you understand how DocuSign organizes your contracts within its system. You can use this structure to better organize future sends.

**What comprehensive data does the `get_envelope` tool retrieve for a specific ID?**
The tool pulls all metadata associated with an envelope's unique ID. This includes status updates, template links, and recipient information without needing to perform a broader search. It’s your quickest way to inspect one document.