Skip to main content
skill CX Codex

docusign-automation — Claude Code skill: automate e-signature workflows

docusign-automation is a Claude Code skill that automates DocuSign workflows through Rube MCP, including template management, envelope creation, sending documents for signature, and status tracking.

MIT 125 installs ★ 3,785 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add davepoon/buildwithclaude --skill docusign-automation -a claude-code
Open on GitHub

What docusign-automation does

This skill connects Claude Code to Composio's DocuSign toolkit through Rube MCP, letting you programmatically manage the full signing cycle. You can search and select templates, create envelopes with recipient role assignments, send documents for signature, and monitor each signer's progress. It uses RUBE_SEARCH_TOOLS, RUBE_MANAGE_CONNECTIONS, and a suite of DOCUSIGN_* commands for templates, envelopes, and status queries.

Setup requires adding https://rube.app/mcp as an MCP server in your client config and activating a DocuSign connection via OAuth. Always call RUBE_SEARCH_TOOLS first to retrieve current tool schemas. Template role names are case-sensitive and must match exactly. Envelope state flows as created → sent → delivered → signed → completed; note that 'delivered' only means the signing email was opened, not that the document was actually signed.

What it helps with

  • send a document for signature using a DocuSign template with recipient assignments
  • locate a specific template in your account and retrieve its structure and roles
  • check whether each recipient has signed and track the overall envelope status
  • add extra templates or documents to a draft envelope before sending
  • manage envelope lifecycle: create drafts, send, and void

Example prompts for the agent

  • Find the 'NDA Template' and send it to [email protected] for signature
  • Check if the contract envelope has been signed by all recipients and when it was sent
  • Create a draft envelope from the invoice template, add the terms addendum, then send it out

How to install docusign-automation

1Skills CLI (Vercel)

npx skills add davepoon/buildwithclaude --skill docusign-automation -a claude-code

2Manually: put the files in place

~/.claude/skills/docusign-automation/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/docusign-automation/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about docusign-automation

How do I install docusign-automation for Claude Code?

Run npx skills add davepoon/buildwithclaude --skill docusign-automation -a claude-code and check ~/.claude/skills/docusign-automation/SKILL.md for setup steps.

What setup is required before using this skill?

Add https://rube.app/mcp as an MCP server in your config, confirm RUBE_SEARCH_TOOLS is available, then activate a DocuSign connection via RUBE_MANAGE_CONNECTIONS — the skill will guide you through OAuth.

What's the difference between 'delivered' and 'signed' status?

'delivered' means the recipient opened the signing email, but 'signed' means they actually signed. The final state 'completed' indicates all signers have signed.

Source text

SKILL.md · MIT
---
name: docusign-automation
description: "Automate DocuSign tasks via Rube MCP (Composio): templates, envelopes, signatures, document management. Always search tools first for current schemas."
requires:
  mcp: [rube]
category: business-productivity
---

# DocuSign Automation via Rube MCP

Automate DocuSign e-signature workflows through Composio's DocuSign toolkit via Rube MCP.

**Toolkit docs**: [composio.dev/toolkits/docusign](https://composio.dev/toolkits/docusign)

## Prerequisites

- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active DocuSign connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `docusign`
- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas

## Setup

**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.


1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `docusign`
3. If connection is not ACTIVE, follow the returned auth link to complete DocuSign OAuth
4. Confirm connection status shows ACTIVE before running any workflows

## Core Workflows

### 1. Browse and Select Templates

**When to use**: User wants to find available document templates for sending

**Tool sequence**:
1. `DOCUSIGN_LIST_ALL_TEMPLATES` - List all available templates [Required]
2. `DOCUSIGN_GET_TEMPLATE` - Get detailed template information [Optional]

**Key parameters**:
- For listing: Optional search/filter parameters
- For details: `templateId` (from list results)
- Response includes template `templateId`, `name`, `description`, roles, and fields

**Pitfalls**:
- Template IDs are GUIDs (e.g., '12345678-abcd-1234-efgh-123456789012')
- Templates define recipient roles with signing tabs; understand roles before creating envelopes
- Large template libraries require pagination; check for continuation tokens
- Template access depends on account permissions

### 2. Create and Send Envelopes from Templates

**When to use**: User wants to send documents for signature using a pre-built template

**Tool sequence**:
1. `DOCUSIGN_LIST_ALL_TEMPLATES` - Find the template to use [Prerequisite]
2. `DOCUSIGN_GET_TEMPLATE` - Review template roles and fields [Optional]
3. `DOCUSIGN_CREATE_ENVELOPE_FROM_TEMPLATE` - Create the envelope [Required]
4. `DOCUSIGN_SEND_ENVELOPE` - Send the envelope for signing [Required]

**Key parameters**:
- For CREATE_ENVELOPE_FROM_TEMPLATE:
  - `templateId`: Template to use
  - `templateRoles`: Array of role assignments with `roleName`, `name`, `email`
  - `status`: 'created' (draft) or 'sent' (send immediately)
  - `emailSubject`: Custom subject line for the signing email
  - `emailBlurb`: Custom message in the signing email
- For SEND_ENVELOPE:
  - `envelopeId`: Envelope ID from creation response

**Pitfalls**:
- `templateRoles` must match the role names defined in the template exactly (case-sensitive)
- Setting `status` to 'sent' during creation sends immediately; use 'created' for drafts
- If status is 'sent' at creation, no need to call SEND_ENVELOPE separately
- Each role requires at minimum `roleName`, `name`, and `email`
- `emailSubject` overrides the template's default email subject

### 3. Monitor Envelope Status

**When to use**: User wants to check the status of sent envelopes or track signing progress

**Tool sequence**:
1. `DOCUSIGN_GET_ENVELOPE` - Get envelope details and status [Required]

**Key parameters**:
- `envelopeId`: Envelope identifier (GUID)
- Response includes `status`, `recipients`, `sentDateTime`, `completedDateTime`

**Pitfalls**:
- Envelope statuses: 'created', 'sent', 'delivered', 'signed', 'completed', 'declined', 'voided'
- 'delivered' means the email was opened, not that the document was signed
- 'completed' means all recipients have signed
- Recipients array shows individual signing status per recipient
- Envelope IDs are GUIDs; always resolve from creation or search results

### 4. Add Templates to Existing Envelopes

**When to use**: User wants to add additional documents or templates to an existing envelope

**Tool sequence**:
1. `DOCUSIGN_GET_ENVELOPE` - Verify envelope exists and is in draft state [Prerequisite]
2. `DOCUSIGN_ADD_TEMPLATES_TO_DOCUMENT_IN_ENVELOPE` - Add template to envelope [Required]

**Key parameters**:
- `envelopeId`: Target envelope ID
- `documentId`: Document ID within the envelope
- `templateId`: Template to add

**Pitfalls**:
- Envelope must be in 'created' (draft) status to add templates
- Cannot add templates to already-sent envelopes
- Document IDs are sequential within an envelope (starting from '1')
- Adding a template merges its fields and roles into the existing envelope

### 5. Manage Envelope Lifecycle

**When to use**: User wants to send, void, or manage draft envelopes

**Tool sequence**:
1. `DOCUSIGN_GET_ENVELOPE` - Check current envelope status [Prerequisite]
2. `DOCUSIGN_SEND_ENVELOPE` - Send a draft envelope [Optional]

**Key parameters**:
- `envelopeId`: Envelope to manage
- For sending: envelope must be in 'created' status with all required recipients

**Pitfalls**:
- Only 'created' (draft) envelopes can be sent
- Sent envelopes cannot be unsent; they can only be voided
- Voiding an envelope notifies all recipients
- All required recipients must have valid email addresses before sending

## Common Patterns

### ID Resolution

**Template name -> Template ID**:
```
1. Call DOCUSIGN_LIST_ALL_TEMPLATES
2. Find template by name in results
3. Extract templateId (GUID format)
```

**Envelope tracking**:
```
1. Store envelopeId from CREATE_ENVELOPE_FROM_TEMPLATE response
2. Call DOCUSIGN_GET_ENVELOPE periodically to check status
3. Check recipient-level status for individual signing progress
```

### Template Role Mapping

When creating an envelope from a template:
```
1. Call DOCUSIGN_GET_TEMPLATE to see defined roles
2. Map each role to actual recipients:
   {
     "roleName": "Signer 1",     // Must match template role name exactly
     "name": "John Smith",
     "email": "[email protected]"
   }
3. Include ALL required roles in templateRoles array
```

### Envelope Status Flow

```
created (draft) -> sent -> delivered -> signed -> completed
                       \-> declined
                       \-> voided (by sender)
```

## Known Pitfalls

**Template Roles**:
- Role names are case-sensitive; must match template definition exactly
- All required roles must be assigned when creating an envelope
- Missing role assignments cause envelope creation to fail

**Envelope Status**:
- 'delivered' means email opened, NOT document signed
- 'completed' is the final successful state (all parties signed)
- Status transitions are one-way; cannot revert to previous states

**GUIDs**:
- All DocuSign IDs (templates, envelopes) are GUID format
- Always resolve names to GUIDs via list/search endpoints
- Do not hardcode GUIDs; they are unique per account

**Rate Limits**:
- DocuSign API has per-account rate limits
- Bulk envelope creation should be throttled
- Polling envelope status should use reasonable intervals (30-60 seconds)

**Response Parsing**:
- Response data may be nested under `data` key
- Recipient information is nested within envelope response
- Date fields use ISO 8601 format
- Parse defensively with fallbacks for optional fields

## Quick Reference

| Task | Tool Slug | Key Params |
|------|-----------|------------|
| List templates | DOCUSIGN_LIST_ALL_TEMPLATES | (optional filters) |
| Get template | DOCUSIGN_GET_TEMPLATE | templateId |
| Create envelope | DOCUSIGN_CREATE_ENVELOPE_FROM_TEMPLATE | templateId, templateRoles, status |
| Send envelope | DOCUSIGN_SEND_ENVELOPE | envelopeId |
| Get envelope status | DOCUSIGN_GET_ENVELOPE | envelopeId |
| Add template to envelope | DOCUSIGN_ADD_TEMPLATES_TO_DOCUMENT_IN_ENVELOPE | envelopeId, documentId, templateId |

---
*Powered by [Composio](https://composio.dev)*

© davepoon · MIT · davepoon/buildwithclaude

Similar skills

All skills for Automation and no-code: n8n, Zapier, Make →

From the same set235

The whole set →
brevo-automation brevo-automation automates Brevo work through Rube MCP, from campaign updates to template management and sender checks. Useful for email workflows handled by an agent. CX Codex +1 126installs hubspot-automation hubspot-automation automates HubSpot CRM workflows covering contacts, deals, companies, and tickets via Rube MCP and Composio. CX Codex +1 126installs microsoft-teams-automation microsoft-teams-automation — a skill for Claude Code, Codex, Cursor and other agents that automates Microsoft Teams through Rube MCP (Composio): send messages, schedule meetings, manage channels. CX Codex +1 126installs trello-automation The trello-automation skill operates Trello boards, lists, and cards through Rube MCP. Use it to create tasks, find cards, assign members, or move work between lists. CX Codex +1 125installs make-automation make-automation is a Claude Code skill that uses Rube MCP to inspect Make scenario operation logs and validate language codes and IANA timezones. CX Codex +1 125installs render-automation render-automation — a skill to automate Render cloud operations through Rube MCP and Composio. List services, trigger deployments, and monitor status from your IDE. CX Codex +1 125installs bamboohr-automation bamboohr-automation is a Claude Code skill for BambooHR operations: searching employees, managing time off, updating data, and handling dependents and benefits. CX Codex +1 124installs datadog-automation datadog-automation automates Datadog tasks: query metrics, search logs, manage monitors and dashboards, create events and downtimes. Requires connected Rube MCP and active Datadog authentication. CX Codex +1 124installs

Project sponsors

Companies that keep this analytics open